code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
public void setValue(Quaternionf rot) {
mX = rot.x;
mY = rot.y;
mZ = rot.z;
mW = rot.w;
} | java |
public void update(int width, int height, float[] data)
throws IllegalArgumentException
{
if ((width <= 0) || (height <= 0) ||
(data == null) || (data.length < height * width * mFloatsPerPixel))
{
throw new IllegalArgumentException();
}
NativeFloatImage.update(getNative(), width, height, 0, data);
} | java |
public String[] getUrl() {
String[] valueDestination = new String[ url.size() ];
this.url.getValue(valueDestination);
return valueDestination;
} | java |
protected float getSizeArcLength(float angle) {
if (mRadius <= 0) {
throw new IllegalArgumentException("mRadius is not specified!");
}
return angle == Float.MAX_VALUE ? Float.MAX_VALUE :
LayoutHelpers.lengthOfArc(angle, mRadius);
} | java |
public void writeLine(String pattern, Object... parameters) {
String line = (parameters == null || parameters.length == 0) ? pattern
: String.format(pattern, parameters);
lines.add(0, line); // we'll write bottom to top, then purge unwritten
// lines from end
updateHUD();
} | java |
public void setCanvasWidthHeight(int width, int height) {
hudWidth = width;
hudHeight = height;
HUD = Bitmap.createBitmap(width, height, Config.ARGB_8888);
canvas = new Canvas(HUD);
texture = null;
} | java |
public static void scale(GVRMesh mesh, float x, float y, float z) {
final float [] vertices = mesh.getVertices();
final int vsize = vertices.length;
for (int i = 0; i < vsize; i += 3) {
vertices[i] *= x;
vertices[i + 1] *= y;
vertices[i + 2] *= z;
}
mesh.setVertices(vertices);
} | java |
public static void resize(GVRMesh mesh, float xsize, float ysize, float zsize) {
float dim[] = getBoundingSize(mesh);
scale(mesh, xsize / dim[0], ysize / dim[1], zsize / dim[2]);
} | java |
public static void resize(GVRMesh mesh, float size) {
float dim[] = getBoundingSize(mesh);
float maxsize = 0.0f;
if (dim[0] > maxsize) maxsize = dim[0];
if (dim[1] > maxsize) maxsize = dim[1];
if (dim[2] > maxsize) maxsize = dim[2];
scale(mesh, size / maxsize);
} | java |
public static float[] getBoundingSize(GVRMesh mesh) {
final float [] dim = new float[3];
final float [] vertices = mesh.getVertices();
final int vsize = vertices.length;
float minx = Integer.MAX_VALUE;
float miny = Integer.MAX_VALUE;
float minz = Integer.MAX_VALUE;
float maxx = Integer.MIN_VALUE;
float maxy = Integer.MIN_VALUE;
float maxz = Integer.MIN_VALUE;
for (int i = 0; i < vsize; i += 3) {
if (vertices[i] < minx) minx = vertices[i];
if (vertices[i] > maxx) maxx = vertices[i];
if (vertices[i + 1] < miny) miny = vertices[i + 1];
if (vertices[i + 1] > maxy) maxy = vertices[i + 1];
if (vertices[i + 2] < minz) minz = vertices[i + 2];
if (vertices[i + 2] > maxz) maxz = vertices[i + 2];
}
dim[0] = maxx - minx;
dim[1] = maxy - miny;
dim[2] = maxz - minz;
return dim;
} | java |
public static GVRMesh createQuad(GVRContext gvrContext, float width, float height) {
GVRMesh mesh = new GVRMesh(gvrContext);
float[] vertices = { width * -0.5f, height * 0.5f, 0.0f, width * -0.5f,
height * -0.5f, 0.0f, width * 0.5f, height * 0.5f, 0.0f,
width * 0.5f, height * -0.5f, 0.0f };
mesh.setVertices(vertices);
final float[] normals = { 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f, 1.0f };
mesh.setNormals(normals);
final float[] texCoords = { 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f,
1.0f };
mesh.setTexCoords(texCoords);
char[] triangles = { 0, 1, 2, 1, 3, 2 };
mesh.setIndices(triangles);
return mesh;
} | java |
void onSurfaceChanged(int width, int height) {
Log.v(TAG, "onSurfaceChanged");
final VrAppSettings.EyeBufferParams.DepthFormat depthFormat = mApplication.getAppSettings().getEyeBufferParams().getDepthFormat();
mApplication.getConfigurationManager().configureRendering(VrAppSettings.EyeBufferParams.DepthFormat.DEPTH_24_STENCIL_8 == depthFormat);
} | java |
void onDrawEye(int eye, int swapChainIndex, boolean use_multiview) {
mCurrentEye = eye;
if (!(mSensoredScene == null || !mMainScene.equals(mSensoredScene))) {
GVRCameraRig mainCameraRig = mMainScene.getMainCameraRig();
if (use_multiview) {
if (DEBUG_STATS) {
mTracerDrawEyes1.enter(); // this eye is drawn first
mTracerDrawEyes2.enter();
}
GVRRenderTarget renderTarget = mRenderBundle.getRenderTarget(EYE.MULTIVIEW, swapChainIndex);
GVRCamera camera = mMainScene.getMainCameraRig().getCenterCamera();
GVRCamera left_camera = mMainScene.getMainCameraRig().getLeftCamera();
renderTarget.cullFromCamera(mMainScene, camera,mRenderBundle.getShaderManager());
captureCenterEye(renderTarget, true);
capture3DScreenShot(renderTarget, true);
renderTarget.render(mMainScene, left_camera, mRenderBundle.getShaderManager(),mRenderBundle.getPostEffectRenderTextureA(),
mRenderBundle.getPostEffectRenderTextureB());
captureRightEye(renderTarget, true);
captureLeftEye(renderTarget, true);
captureFinish();
if (DEBUG_STATS) {
mTracerDrawEyes1.leave();
mTracerDrawEyes2.leave();
}
} else {
if (eye == 1) {
if (DEBUG_STATS) {
mTracerDrawEyes1.enter();
}
GVRCamera rightCamera = mainCameraRig.getRightCamera();
GVRRenderTarget renderTarget = mRenderBundle.getRenderTarget(EYE.RIGHT, swapChainIndex);
renderTarget.render(mMainScene, rightCamera, mRenderBundle.getShaderManager(), mRenderBundle.getPostEffectRenderTextureA(),
mRenderBundle.getPostEffectRenderTextureB());
captureRightEye(renderTarget, false);
captureFinish();
if (DEBUG_STATS) {
mTracerDrawEyes1.leave();
mTracerDrawEyes.leave();
}
} else {
if (DEBUG_STATS) {
mTracerDrawEyes1.leave();
mTracerDrawEyes.leave();
}
GVRRenderTarget renderTarget = mRenderBundle.getRenderTarget(EYE.LEFT, swapChainIndex);
GVRCamera leftCamera = mainCameraRig.getLeftCamera();
capture3DScreenShot(renderTarget, false);
renderTarget.cullFromCamera(mMainScene, mainCameraRig.getCenterCamera(), mRenderBundle.getShaderManager());
captureCenterEye(renderTarget, false);
renderTarget.render(mMainScene, leftCamera, mRenderBundle.getShaderManager(), mRenderBundle.getPostEffectRenderTextureA(), mRenderBundle.getPostEffectRenderTextureB());
captureLeftEye(renderTarget, false);
if (DEBUG_STATS) {
mTracerDrawEyes2.leave();
}
}
}
}
} | java |
public GVRAndroidResource openResource(String filePath) throws IOException {
// Error tolerance: Remove initial '/' introduced by file::///filename
// In this case, the path is interpreted as relative to defaultPath,
// which is the root of the filesystem.
if (filePath.startsWith(File.separator)) {
filePath = filePath.substring(File.separator.length());
}
filePath = adaptFilePath(filePath);
String path;
int resourceId;
GVRAndroidResource resourceKey;
switch (volumeType) {
case ANDROID_ASSETS:
// Resolve '..' and '.'
path = getFullPath(defaultPath, filePath);
path = new File(path).getCanonicalPath();
if (path.startsWith(File.separator)) {
path = path.substring(1);
}
resourceKey = new GVRAndroidResource(gvrContext, path);
break;
case ANDROID_RESOURCE:
path = FileNameUtils.getBaseName(filePath);
resourceId = gvrContext.getContext().getResources().getIdentifier(path, "raw", gvrContext.getContext().getPackageName());
if (resourceId == 0) {
throw new FileNotFoundException(filePath + " resource not found");
}
resourceKey = new GVRAndroidResource(gvrContext, resourceId);
break;
case LINUX_FILESYSTEM:
resourceKey = new GVRAndroidResource(
getFullPath(defaultPath, filePath));
break;
case ANDROID_SDCARD:
String linuxPath = Environment.getExternalStorageDirectory()
.getAbsolutePath();
resourceKey = new GVRAndroidResource(
getFullPath(linuxPath, defaultPath, filePath));
break;
case INPUT_STREAM:
resourceKey = new GVRAndroidResource(getFullPath(defaultPath, filePath), volumeInputStream);
break;
case NETWORK:
resourceKey = new GVRAndroidResource(gvrContext,
getFullURL(defaultPath, filePath), enableUrlLocalCache);
break;
default:
throw new IOException(
String.format("Unrecognized volumeType %s", volumeType));
}
return addResource(resourceKey);
} | java |
protected String adaptFilePath(String filePath) {
// Convert windows file path to target FS
String targetPath = filePath.replaceAll("\\\\", volumeType.getSeparator());
return targetPath;
} | java |
public FloatBuffer getFloatVec(String attributeName)
{
int size = getAttributeSize(attributeName);
if (size <= 0)
{
return null;
}
size *= 4 * getVertexCount();
ByteBuffer buffer = ByteBuffer.allocateDirect(size).order(ByteOrder.nativeOrder());
FloatBuffer data = buffer.asFloatBuffer();
if (!NativeVertexBuffer.getFloatVec(getNative(), attributeName, data, 0, 0))
{
throw new IllegalArgumentException("Attribute name " + attributeName + " cannot be accessed");
}
return data;
} | java |
public float[] getFloatArray(String attributeName)
{
float[] array = NativeVertexBuffer.getFloatArray(getNative(), attributeName);
if (array == null)
{
throw new IllegalArgumentException("Attribute name " + attributeName + " cannot be accessed");
}
return array;
} | java |
public IntBuffer getIntVec(String attributeName)
{
int size = getAttributeSize(attributeName);
if (size <= 0)
{
return null;
}
size *= 4 * getVertexCount();
ByteBuffer buffer = ByteBuffer.allocateDirect(size).order(ByteOrder.nativeOrder());
IntBuffer data = buffer.asIntBuffer();
if (!NativeVertexBuffer.getIntVec(getNative(), attributeName, data, 0, 0))
{
throw new IllegalArgumentException("Attribute name " + attributeName + " cannot be accessed");
}
return data;
} | java |
public int[] getIntArray(String attributeName)
{
int[] array = NativeVertexBuffer.getIntArray(getNative(), attributeName);
if (array == null)
{
throw new IllegalArgumentException("Attribute name " + attributeName + " cannot be accessed");
}
return array;
} | java |
public float getSphereBound(float[] sphere)
{
if ((sphere == null) || (sphere.length != 4) ||
((NativeVertexBuffer.getBoundingVolume(getNative(), sphere)) < 0))
{
throw new IllegalArgumentException("Cannot copy sphere bound into array provided");
}
return sphere[0];
} | java |
public boolean getBoxBound(float[] corners)
{
int rc;
if ((corners == null) || (corners.length != 6) ||
((rc = NativeVertexBuffer.getBoundingVolume(getNative(), corners)) < 0))
{
throw new IllegalArgumentException("Cannot copy box bound into array provided");
}
return rc != 0;
} | java |
public void load(String soundFile)
{
if (mSoundFile != null)
{
unload();
}
mSoundFile = soundFile;
if (mAudioListener != null)
{
mAudioListener.getAudioEngine().preloadSoundFile(soundFile);
Log.d("SOUND", "loaded audio file %s", getSoundFile());
}
} | java |
public void unload()
{
if (mAudioListener != null)
{
Log.d("SOUND", "unloading audio source %d %s", getSourceId(), getSoundFile());
mAudioListener.getAudioEngine().unloadSoundFile(getSoundFile());
}
mSoundFile = null;
mSourceId = GvrAudioEngine.INVALID_ID;
} | java |
public void pause()
{
if (mAudioListener != null)
{
int sourceId = getSourceId();
if (sourceId != GvrAudioEngine.INVALID_ID)
{
mAudioListener.getAudioEngine().pauseSound(sourceId);
}
}
} | java |
public void stop()
{
if (mAudioListener != null)
{
Log.d("SOUND", "stopping audio source %d %s", getSourceId(), getSoundFile());
mAudioListener.getAudioEngine().stopSound(getSourceId());
}
} | java |
public void setVolume(float volume)
{
// Save this in case this audio source is not being played yet
mVolume = volume;
if (isPlaying() && (getSourceId() != GvrAudioEngine.INVALID_ID))
{
// This will actually work only if the sound file is being played
mAudioListener.getAudioEngine().setSoundVolume(getSourceId(), getVolume());
}
} | java |
public float get(Layout.Axis axis) {
switch (axis) {
case X:
return x;
case Y:
return y;
case Z:
return z;
default:
throw new RuntimeAssertion("Bad axis specified: %s", axis);
}
} | java |
public void set(float val, Layout.Axis axis) {
switch (axis) {
case X:
x = val;
break;
case Y:
y = val;
break;
case Z:
z = val;
break;
default:
throw new RuntimeAssertion("Bad axis specified: %s", axis);
}
} | java |
public Vector3Axis delta(Vector3f v) {
Vector3Axis ret = new Vector3Axis(Float.NaN, Float.NaN, Float.NaN);
if (x != Float.NaN && v.x != Float.NaN && !equal(x, v.x)) {
ret.set(x - v.x, Layout.Axis.X);
}
if (y != Float.NaN && v.y != Float.NaN && !equal(y, v.y)) {
ret.set(y - v.y, Layout.Axis.Y);
}
if (z != Float.NaN && v.z != Float.NaN && !equal(z, v.z)) {
ret.set(z - v.z, Layout.Axis.Z);
}
return ret;
} | java |
public int setPageCount(final int num) {
int diff = num - getCheckableCount();
if (diff > 0) {
addIndicatorChildren(diff);
} else if (diff < 0) {
removeIndicatorChildren(-diff);
}
if (mCurrentPage >=num ) {
mCurrentPage = 0;
}
setCurrentPage(mCurrentPage);
return diff;
} | java |
public boolean setCurrentPage(final int page) {
Log.d(TAG, "setPageId pageId = %d", page);
return (page >= 0 && page < getCheckableCount()) && check(page);
} | java |
public void loadPhysics(String filename, GVRScene scene) throws IOException
{
GVRPhysicsLoader.loadPhysicsFile(getGVRContext(), filename, true, scene);
} | java |
public void rotateToFaceCamera(final GVRTransform transform) {
//see http://stackoverflow.com/questions/5782658/extracting-yaw-from-a-quaternion
final GVRTransform t = getMainCameraRig().getHeadTransform();
final Quaternionf q = new Quaternionf(0, t.getRotationY(), 0, t.getRotationW()).normalize();
transform.rotateWithPivot(q.w, q.x, q.y, q.z, 0, 0, 0);
} | java |
public float rotateToFaceCamera(final Widget widget) {
final float yaw = getMainCameraRigYaw();
GVRTransform t = getMainCameraRig().getHeadTransform();
widget.rotateWithPivot(t.getRotationW(), 0, t.getRotationY(), 0, 0, 0, 0);
return yaw;
} | java |
public void updateFrontFacingRotation(float rotation) {
if (!Float.isNaN(rotation) && !equal(rotation, frontFacingRotation)) {
final float oldRotation = frontFacingRotation;
frontFacingRotation = rotation % 360;
for (OnFrontRotationChangedListener listener : mOnFrontRotationChangedListeners) {
try {
listener.onFrontRotationChanged(this, frontFacingRotation, oldRotation);
} catch (Exception e) {
e.printStackTrace();
Log.e(TAG, e, "updateFrontFacingRotation()");
}
}
}
} | java |
public void rotateToFront() {
GVRTransform transform = mSceneRootObject.getTransform();
transform.setRotation(1, 0, 0, 0);
transform.rotateByAxisWithPivot(-frontFacingRotation + 180, 0, 1, 0, 0, 0, 0);
} | java |
public void setScale(final float scale) {
if (equal(mScale, scale) != true) {
Log.d(TAG, "setScale(): old: %.2f, new: %.2f", mScale, scale);
mScale = scale;
setScale(mSceneRootObject, scale);
setScale(mMainCameraRootObject, scale);
setScale(mLeftCameraRootObject, scale);
setScale(mRightCameraRootObject, scale);
for (OnScaledListener listener : mOnScaledListeners) {
try {
listener.onScaled(scale);
} catch (Exception e) {
e.printStackTrace();
Log.e(TAG, e, "setScale()");
}
}
}
} | java |
public GVRAnimation setRepeatMode(int repeatMode) {
if (GVRRepeatMode.invalidRepeatMode(repeatMode)) {
throw new IllegalArgumentException(repeatMode
+ " is not a valid repetition type");
}
mRepeatMode = repeatMode;
return this;
} | java |
public GVRAnimation setOffset(float startOffset)
{
if(startOffset<0 || startOffset>mDuration){
throw new IllegalArgumentException("offset should not be either negative or greater than duration");
}
animationOffset = startOffset;
mDuration = mDuration-animationOffset;
return this;
} | java |
public GVRAnimation setDuration(float start, float end)
{
if(start>end || start<0 || end>mDuration){
throw new IllegalArgumentException("start and end values are wrong");
}
animationOffset = start;
mDuration = end-start;
return this;
} | java |
public GVRAnimation setOnFinish(GVROnFinish callback) {
mOnFinish = callback;
// Do the instance-of test at set-time, not at use-time
mOnRepeat = callback instanceof GVROnRepeat ? (GVROnRepeat) callback
: null;
if (mOnRepeat != null) {
mRepeatCount = -1; // loop until iterate() returns false
}
return this;
} | java |
public synchronized void bindShader(GVRScene scene, boolean isMultiview)
{
GVRRenderPass pass = mRenderPassList.get(0);
GVRShaderId shader = pass.getMaterial().getShaderType();
GVRShader template = shader.getTemplate(getGVRContext());
if (template != null)
{
template.bindShader(getGVRContext(), this, scene, isMultiview);
}
for (int i = 1; i < mRenderPassList.size(); ++i)
{
pass = mRenderPassList.get(i);
shader = pass.getMaterial().getShaderType();
template = shader.getTemplate(getGVRContext());
if (template != null)
{
template.bindShader(getGVRContext(), pass, scene, isMultiview);
}
}
} | java |
public GVRRenderData setCullFace(GVRCullFaceEnum cullFace, int passIndex) {
if (passIndex < mRenderPassList.size()) {
mRenderPassList.get(passIndex).setCullFace(cullFace);
} else {
Log.e(TAG, "Trying to set cull face to a invalid pass. Pass " + passIndex + " was not created.");
}
return this;
} | java |
public GVRRenderData setDrawMode(int drawMode) {
if (drawMode != GL_POINTS && drawMode != GL_LINES
&& drawMode != GL_LINE_STRIP && drawMode != GL_LINE_LOOP
&& drawMode != GL_TRIANGLES && drawMode != GL_TRIANGLE_STRIP
&& drawMode != GL_TRIANGLE_FAN) {
throw new IllegalArgumentException(
"drawMode must be one of GL_POINTS, GL_LINES, GL_LINE_STRIP, GL_LINE_LOOP, GL_TRIANGLES, GL_TRIANGLE_FAN, GL_TRIANGLE_STRIP.");
}
NativeRenderData.setDrawMode(getNative(), drawMode);
return this;
} | java |
public boolean fling(float velocityX, float velocityY, float velocityZ) {
boolean scrolled = true;
float viewportX = mScrollable.getViewPortWidth();
if (Float.isNaN(viewportX)) {
viewportX = 0;
}
float maxX = Math.min(MAX_SCROLLING_DISTANCE,
viewportX * MAX_VIEWPORT_LENGTHS);
float viewportY = mScrollable.getViewPortHeight();
if (Float.isNaN(viewportY)) {
viewportY = 0;
}
float maxY = Math.min(MAX_SCROLLING_DISTANCE,
viewportY * MAX_VIEWPORT_LENGTHS);
float xOffset = (maxX * velocityX)/VELOCITY_MAX;
float yOffset = (maxY * velocityY)/VELOCITY_MAX;
Log.d(Log.SUBSYSTEM.LAYOUT, TAG, "fling() velocity = [%f, %f, %f] offset = [%f, %f]",
velocityX, velocityY, velocityZ,
xOffset, yOffset);
if (equal(xOffset, 0)) {
xOffset = Float.NaN;
}
if (equal(yOffset, 0)) {
yOffset = Float.NaN;
}
// TODO: Think about Z-scrolling
mScrollable.scrollByOffset(xOffset, yOffset, Float.NaN, mInternalScrollListener);
return scrolled;
} | java |
public int scrollToNextPage() {
Log.d(Log.SUBSYSTEM.LAYOUT, TAG, "scrollToNextPage getCurrentPage() = %d currentIndex = %d",
getCurrentPage(), mCurrentItemIndex);
if (mSupportScrollByPage) {
scrollToPage(getCurrentPage() + 1);
} else {
Log.w(TAG, "Pagination is not enabled!");
}
return mCurrentItemIndex;
} | java |
public int scrollToPage(int pageNumber) {
Log.d(Log.SUBSYSTEM.LAYOUT, TAG, "scrollToPage pageNumber = %d mPageCount = %d",
pageNumber, mPageCount);
if (mSupportScrollByPage &&
(mScrollOver || (pageNumber >= 0 && pageNumber <= mPageCount - 1))) {
scrollToItem(getFirstItemIndexOnPage(pageNumber));
} else {
Log.w(TAG, "Pagination is not enabled!");
}
return mCurrentItemIndex;
} | java |
public int scrollToItem(int position) {
Log.d(Log.SUBSYSTEM.LAYOUT, TAG, "scrollToItem position = %d", position);
scrollToPosition(position);
return mCurrentItemIndex;
} | java |
public int getCurrentPage() {
int currentPage = 1;
int count = mScrollable.getScrollingItemsCount();
if (mSupportScrollByPage && mCurrentItemIndex >= 0 &&
mCurrentItemIndex < count) {
currentPage = (Math.min(mCurrentItemIndex + mPageSize - 1, count - 1)/mPageSize);
}
return currentPage;
} | java |
public String getName()
{
GVRSceneObject owner = getOwnerObject();
String name = "";
if (owner != null)
{
name = owner.getName();
if (name == null)
return "";
}
return name;
} | java |
public void setFinalTransformMatrix(Matrix4f finalTransform)
{
float[] mat = new float[16];
finalTransform.get(mat);
NativeBone.setFinalTransformMatrix(getNative(), mat);
} | java |
public Matrix4f getFinalTransformMatrix()
{
final FloatBuffer fb = ByteBuffer.allocateDirect(4*4*4).order(ByteOrder.nativeOrder()).asFloatBuffer();
NativeBone.getFinalTransformMatrix(getNative(), fb);
return new Matrix4f(fb);
} | java |
@Override
public void prettyPrint(StringBuffer sb, int indent)
{
sb.append(Log.getSpaces(indent));
sb.append(GVRBone.class.getSimpleName());
sb.append(" [name=" + getName() + ", boneId=" + getBoneId()
+ ", offsetMatrix=" + getOffsetMatrix()
+ ", finalTransformMatrix=" + getFinalTransformMatrix() // crashes debugger
+ "]");
sb.append(System.lineSeparator());
} | java |
public void update(int width, int height, int sampleCount) {
if (capturing) {
throw new IllegalStateException("Cannot update backing texture while capturing");
}
this.width = width;
this.height = height;
if (sampleCount == 0)
captureTexture = new GVRRenderTexture(getGVRContext(), width, height);
else
captureTexture = new GVRRenderTexture(getGVRContext(), width, height, sampleCount);
setRenderTexture(captureTexture);
readBackBuffer = new int[width * height];
} | java |
public void setCapture(boolean capture, float fps) {
capturing = capture;
NativeTextureCapturer.setCapture(getNative(), capture, fps);
} | java |
public void setTexture(GVRRenderTexture texture)
{
mTexture = texture;
NativeRenderTarget.setTexture(getNative(), texture.getNative());
} | java |
public <T extends Widget & Checkable> boolean addOnCheckChangedListener
(OnCheckChangedListener listener) {
final boolean added;
synchronized (mListeners) {
added = mListeners.add(listener);
}
if (added) {
List<T> c = getCheckableChildren();
for (int i = 0; i < c.size(); ++i) {
listener.onCheckChanged(this, c.get(i), i);
}
}
return added;
} | java |
public <T extends Widget & Checkable> boolean check(int checkableIndex) {
List<T> children = getCheckableChildren();
T checkableWidget = children.get(checkableIndex);
return checkInternal(checkableWidget, true);
} | java |
public <T extends Widget & Checkable> boolean uncheck(int checkableIndex) {
List<T> children = getCheckableChildren();
T checkableWidget = children.get(checkableIndex);
return checkInternal(checkableWidget, false);
} | java |
public <T extends Widget & Checkable> void clearChecks() {
List<T> children = getCheckableChildren();
for (T c : children) {
c.setChecked(false);
}
} | java |
public <T extends Widget & Checkable> List<T> getCheckedWidgets() {
List<T> checked = new ArrayList<>();
for (Widget c : getChildren()) {
if (c instanceof Checkable && ((Checkable) c).isChecked()) {
checked.add((T) c);
}
}
return checked;
} | java |
public <T extends Widget & Checkable> List<Integer> getCheckedWidgetIndexes() {
List<Integer> checked = new ArrayList<>();
List<Widget> children = getChildren();
final int size = children.size();
for (int i = 0, j = -1; i < size; ++i) {
Widget c = children.get(i);
if (c instanceof Checkable) {
++j;
if (((Checkable) c).isChecked()) {
checked.add(j);
}
}
}
return checked;
} | java |
public <T extends Widget & Checkable> List<T> getCheckableChildren() {
List<Widget> children = getChildren();
ArrayList<T> result = new ArrayList<>();
for (Widget c : children) {
if (c instanceof Checkable) {
result.add((T) c);
}
}
return result;
} | java |
public boolean setUpCameraForVrMode(final int fpsMode) {
cameraSetUpStatus = false;
this.fpsMode = fpsMode;
if (!isCameraOpen) {
Log.e(TAG, "Camera is not open");
return false;
}
if (fpsMode < 0 || fpsMode > 2) {
Log.e(TAG,
"Invalid fpsMode: %d. It can only take values 0, 1, or 2.", fpsMode);
} else {
Parameters params = camera.getParameters();
// check if the device supports vr mode preview
if ("true".equalsIgnoreCase(params.get("vrmode-supported"))) {
Log.v(TAG, "VR Mode supported!");
// set vr mode
params.set("vrmode", 1);
// true if the apps intend to record videos using
// MediaRecorder
params.setRecordingHint(true);
// set preview size
// params.setPreviewSize(640, 480);
// set fast-fps-mode: 0 for 30fps, 1 for 60 fps,
// 2 for 120 fps
params.set("fast-fps-mode", fpsMode);
switch (fpsMode) {
case 0: // 30 fps
params.setPreviewFpsRange(30000, 30000);
break;
case 1: // 60 fps
params.setPreviewFpsRange(60000, 60000);
break;
case 2: // 120 fps
params.setPreviewFpsRange(120000, 120000);
break;
default:
}
// for auto focus
params.set("focus-mode", "continuous-video");
params.setVideoStabilization(false);
if ("true".equalsIgnoreCase(params.get("ois-supported"))) {
params.set("ois", "center");
}
camera.setParameters(params);
cameraSetUpStatus = true;
}
}
return cameraSetUpStatus;
} | java |
static GVROrthogonalCamera makeOrthoShadowCamera(GVRPerspectiveCamera centerCam)
{
GVROrthogonalCamera shadowCam = new GVROrthogonalCamera(centerCam.getGVRContext());
float near = centerCam.getNearClippingDistance();
float far = centerCam.getFarClippingDistance();
float fovy = (float) Math.toRadians(centerCam.getFovY());
float h = (float) (Math.atan(fovy / 2.0f) * far) / 2.0f;
shadowCam.setLeftClippingDistance(-h);
shadowCam.setRightClippingDistance(h);
shadowCam.setTopClippingDistance(h);
shadowCam.setBottomClippingDistance(-h);
shadowCam.setNearClippingDistance(near);
shadowCam.setFarClippingDistance(far);
return shadowCam;
} | java |
static GVRPerspectiveCamera makePerspShadowCamera(GVRPerspectiveCamera centerCam, float coneAngle)
{
GVRPerspectiveCamera camera = new GVRPerspectiveCamera(centerCam.getGVRContext());
float near = centerCam.getNearClippingDistance();
float far = centerCam.getFarClippingDistance();
camera.setNearClippingDistance(near);
camera.setFarClippingDistance(far);
camera.setFovY((float) Math.toDegrees(coneAngle));
camera.setAspectRatio(1.0f);
return camera;
} | java |
private void SetNewViewpoint(String url) {
Viewpoint vp = null;
// get the name without the '#' sign
String vpURL = url.substring(1, url.length());
for (Viewpoint viewpoint : viewpoints) {
if ( viewpoint.getName().equalsIgnoreCase(vpURL) ) {
vp = viewpoint;
}
}
if ( vp != null ) {
// found the Viewpoint matching the url
GVRCameraRig mainCameraRig = gvrContext.getMainScene().getMainCameraRig();
float[] cameraPosition = vp.getPosition();
mainCameraRig.getTransform().setPosition( cameraPosition[0], cameraPosition[1], cameraPosition[2] );
// Set the Gaze controller position which is where the pick ray
// begins in the direction of camera.lookt()
GVRCursorController gazeController = null;
GVRInputManager inputManager = gvrContext.getInputManager();
List<GVRCursorController> controllerList = inputManager.getCursorControllers();
for(GVRCursorController controller: controllerList){
if(controller.getControllerType() == GVRControllerType.GAZE);
{
gazeController = controller;
break;
}
}
if ( gazeController != null) {
gazeController.setOrigin(cameraPosition[0], cameraPosition[1], cameraPosition[2]);
}
}
else {
Log.e(TAG, "Viewpoint named " + vpURL + " not found (defined).");
}
} | java |
private void WebPageCloseOnClick(GVRViewSceneObject gvrWebViewSceneObject, GVRSceneObject gvrSceneObjectAnchor, String url) {
final String urlFinal = url;
webPagePlusUISceneObject = new GVRSceneObject(gvrContext);
webPagePlusUISceneObject.getTransform().setPosition(webPagePlusUIPosition[0], webPagePlusUIPosition[1], webPagePlusUIPosition[2]);
GVRScene mainScene = gvrContext.getMainScene();
Sensor webPageSensor = new Sensor(urlFinal, Sensor.Type.TOUCH, gvrWebViewSceneObject, true);
final GVRSceneObject gvrSceneObjectAnchorFinal = gvrSceneObjectAnchor;
final GVRSceneObject gvrWebViewSceneObjectFinal = gvrWebViewSceneObject;
final GVRSceneObject webPagePlusUISceneObjectFinal = webPagePlusUISceneObject;
webPagePlusUISceneObjectFinal.addChildObject(gvrWebViewSceneObjectFinal);
gvrSceneObjectAnchorFinal.addChildObject(webPagePlusUISceneObjectFinal);
webPageSensor.addISensorEvents(new ISensorEvents() {
boolean uiObjectIsActive = false;
boolean clickDown = true;
@Override
public void onSensorEvent(SensorEvent event) {
if (event.isActive()) {
clickDown = !clickDown;
if (clickDown) {
// Delete the WebView page
gvrSceneObjectAnchorFinal.removeChildObject(webPagePlusUISceneObjectFinal);
webPageActive = false;
webPagePlusUISceneObject = null;
webPageClosed = true; // Make sure click up doesn't open web page behind it
}
}
}
});
} | java |
public Axis getOrientationAxis() {
final Axis axis;
switch(getOrientation()) {
case HORIZONTAL:
axis = Axis.X;
break;
case VERTICAL:
axis = Axis.Y;
break;
case STACK:
axis = Axis.Z;
break;
default:
Log.w(TAG, "Unsupported orientation %s", mOrientation);
axis = Axis.X;
break;
}
return axis;
} | java |
public boolean attachComponent(GVRComponent component) {
if (component.getNative() != 0) {
NativeSceneObject.attachComponent(getNative(), component.getNative());
}
synchronized (mComponents) {
long type = component.getType();
if (!mComponents.containsKey(type)) {
mComponents.put(type, component);
component.setOwnerObject(this);
return true;
}
}
return false;
} | java |
public GVRComponent detachComponent(long type) {
NativeSceneObject.detachComponent(getNative(), type);
synchronized (mComponents) {
GVRComponent component = mComponents.remove(type);
if (component != null) {
component.setOwnerObject(null);
}
return component;
}
} | java |
@SuppressWarnings("unchecked")
public <T extends GVRComponent> ArrayList<T> getAllComponents(long type) {
ArrayList<T> list = new ArrayList<T>();
GVRComponent component = getComponent(type);
if (component != null)
list.add((T) component);
for (GVRSceneObject child : mChildren) {
ArrayList<T> temp = child.getAllComponents(type);
list.addAll(temp);
}
return list;
} | java |
public void setPickingEnabled(boolean enabled) {
if (enabled != getPickingEnabled()) {
if (enabled) {
attachComponent(new GVRSphereCollider(getGVRContext()));
} else {
detachComponent(GVRCollider.getComponentType());
}
}
} | java |
public int removeChildObjectsByName(final String name) {
int removed = 0;
if (null != name && !name.isEmpty()) {
removed = removeChildObjectsByNameImpl(name);
}
return removed;
} | java |
public boolean removeChildObjectByName(final String name) {
if (null != name && !name.isEmpty()) {
GVRSceneObject found = null;
for (GVRSceneObject child : mChildren) {
GVRSceneObject object = child.getSceneObjectByName(name);
if (object != null) {
found = object;
break;
}
}
if (found != null) {
removeChildObject(found);
return true;
}
}
return false;
} | java |
protected void onNewParentObject(GVRSceneObject parent) {
for (GVRComponent comp : mComponents.values()) {
comp.onNewOwnersParent(parent);
}
} | java |
protected void onRemoveParentObject(GVRSceneObject parent) {
for (GVRComponent comp : mComponents.values()) {
comp.onRemoveOwnersParent(parent);
}
} | java |
public void prettyPrint(StringBuffer sb, int indent) {
sb.append(Log.getSpaces(indent));
sb.append(getClass().getSimpleName());
sb.append(" [name=");
sb.append(this.getName());
sb.append("]");
sb.append(System.lineSeparator());
GVRRenderData rdata = getRenderData();
GVRTransform trans = getTransform();
if (rdata == null) {
sb.append(Log.getSpaces(indent + 2));
sb.append("RenderData: null");
sb.append(System.lineSeparator());
} else {
rdata.prettyPrint(sb, indent + 2);
}
sb.append(Log.getSpaces(indent + 2));
sb.append("Transform: "); sb.append(trans);
sb.append(System.lineSeparator());
// dump its children
for (GVRSceneObject child : getChildren()) {
child.prettyPrint(sb, indent + 2);
}
} | java |
public void setControllerModel(GVRSceneObject controllerModel)
{
if (mControllerModel != null)
{
mControllerGroup.removeChildObject(mControllerModel);
}
mControllerModel = controllerModel;
mControllerGroup.addChildObject(mControllerModel);
mControllerModel.setEnable(mShowControllerModel);
} | java |
@Override
public void setCursorDepth(float depth)
{
super.setCursorDepth(depth);
if (mRayModel != null)
{
mRayModel.getTransform().setScaleZ(mCursorDepth);
}
} | java |
@Override
public void setPosition(float x, float y, float z)
{
position.set(x, y, z);
pickDir.set(x, y, z);
pickDir.normalize();
invalidate();
} | java |
@SuppressWarnings("unused")
public Handedness getHandedness()
{
if ((currentControllerEvent == null) || currentControllerEvent.isRecycled())
{
return null;
}
return currentControllerEvent.handedness == 0.0f ?
Handedness.LEFT : Handedness.RIGHT;
} | java |
protected void updatePicker(MotionEvent event, boolean isActive)
{
final MotionEvent newEvent = (event != null) ? event : null;
final ControllerPick controllerPick = new ControllerPick(mPicker, newEvent, isActive);
context.runOnGlThread(controllerPick);
} | java |
public static JSONObject loadJSONAsset(Context context, final String asset) {
if (asset == null) {
return new JSONObject();
}
return getJsonObject(org.gearvrf.widgetlib.main.Utility.readTextFile(context, asset));
} | java |
public static int getJSONColor(final JSONObject json, String elementName) throws JSONException {
Object raw = json.get(elementName);
return convertJSONColor(raw);
} | java |
public static GVRTexture loadFutureCubemapTexture(
GVRContext gvrContext, ResourceCache<GVRImage> textureCache,
GVRAndroidResource resource, int priority,
Map<String, Integer> faceIndexMap) {
GVRTexture tex = new GVRTexture(gvrContext);
GVRImage cached = textureCache.get(resource);
if (cached != null)
{
Log.v("ASSET", "Future Texture: %s loaded from cache", cached.getFileName());
tex.setImage(cached);
}
else
{
AsyncCubemapTexture.get().loadTexture(gvrContext,
CancelableCallbackWrapper.wrap(GVRCubemapImage.class, tex),
resource, priority, faceIndexMap);
}
return tex;
} | java |
public static void loadCubemapTexture(final GVRContext context,
ResourceCache<GVRImage> textureCache,
final TextureCallback callback,
final GVRAndroidResource resource, int priority,
Map<String, Integer> faceIndexMap)
throws IllegalArgumentException
{
validatePriorityCallbackParameters(context, callback, resource,
priority);
final GVRImage cached = textureCache == null
? null
: (GVRImage) textureCache.get(resource);
if (cached != null)
{
Log.v("ASSET", "Texture: %s loaded from cache", cached.getFileName());
context.runOnGlThread(new Runnable()
{
@Override
public void run()
{
callback.loaded(cached, resource);
}
});
}
else
{
TextureCallback actualCallback = (textureCache == null) ? callback
: ResourceCache.wrapCallback(textureCache, callback);
AsyncCubemapTexture.loadTexture(context,
CancelableCallbackWrapper.wrap(GVRCubemapImage.class, actualCallback),
resource, priority, faceIndexMap);
}
} | java |
public static Bitmap decodeStream(InputStream stream, boolean closeStream) {
return AsyncBitmapTexture.decodeStream(stream,
AsyncBitmapTexture.glMaxTextureSize,
AsyncBitmapTexture.glMaxTextureSize, true, null, closeStream);
} | java |
public GVRShaderId getShaderType(Class<? extends GVRShader> shaderClass)
{
GVRShaderId shaderId = mShaderTemplates.get(shaderClass);
if (shaderId == null)
{
GVRContext ctx = getGVRContext();
shaderId = new GVRShaderId(shaderClass);
mShaderTemplates.put(shaderClass, shaderId);
shaderId.getTemplate(ctx);
}
return shaderId;
} | java |
static String makeLayout(String descriptor, String blockName, boolean useUBO)
{
return NativeShaderManager.makeLayout(descriptor, blockName, useUBO);
} | java |
public void rotateWithPivot(float quatW, float quatX, float quatY,
float quatZ, float pivotX, float pivotY, float pivotZ) {
NativeTransform.rotateWithPivot(getNative(), quatW, quatX, quatY,
quatZ, pivotX, pivotY, pivotZ);
} | java |
public static void setFaceNames(String[] nameArray)
{
if (nameArray.length != 6)
{
throw new IllegalArgumentException("nameArray length is not 6.");
}
for (int i = 0; i < 6; i++)
{
faceIndexMap.put(nameArray[i], i);
}
} | java |
public boolean startDrag(final GVRSceneObject sceneObject,
final float hitX, final float hitY, final float hitZ) {
final GVRRigidBody dragMe = (GVRRigidBody)sceneObject.getComponent(GVRRigidBody.getComponentType());
if (dragMe == null || dragMe.getSimulationType() != GVRRigidBody.DYNAMIC || !contains(dragMe))
return false;
GVRTransform t = sceneObject.getTransform();
final Vector3f relPos = new Vector3f(hitX, hitY, hitZ);
relPos.mul(t.getScaleX(), t.getScaleY(), t.getScaleZ());
relPos.rotate(new Quaternionf(t.getRotationX(), t.getRotationY(), t.getRotationZ(), t.getRotationW()));
final GVRSceneObject pivotObject = mPhysicsDragger.startDrag(sceneObject,
relPos.x, relPos.y, relPos.z);
if (pivotObject == null)
return false;
mPhysicsContext.runOnPhysicsThread(new Runnable() {
@Override
public void run() {
mRigidBodyDragMe = dragMe;
NativePhysics3DWorld.startDrag(getNative(), pivotObject.getNative(), dragMe.getNative(),
hitX, hitY, hitZ);
}
});
return true;
} | java |
public void stopDrag() {
mPhysicsDragger.stopDrag();
mPhysicsContext.runOnPhysicsThread(new Runnable() {
@Override
public void run() {
if (mRigidBodyDragMe != null) {
NativePhysics3DWorld.stopDrag(getNative());
mRigidBodyDragMe = null;
}
}
});
} | java |
public void setValue(Vector3f scale) {
mX = scale.x;
mY = scale.y;
mZ = scale.z;
} | java |
public void selectByName(String childName)
{
int i = 0;
GVRSceneObject owner = getOwnerObject();
if (owner == null)
{
return;
}
for (GVRSceneObject child : owner.children())
{
if (child.getName().equals(childName))
{
mSwitchIndex = i;
return;
}
++i;
}
} | java |
public void onAttach(GVRSceneObject sceneObj)
{
super.onAttach(sceneObj);
GVRComponent comp = getComponent(GVRRenderData.getComponentType());
if (comp == null)
{
throw new IllegalStateException("Cannot attach a morph to a scene object without a base mesh");
}
GVRMesh mesh = ((GVRRenderData) comp).getMesh();
if (mesh == null)
{
throw new IllegalStateException("Cannot attach a morph to a scene object without a base mesh");
}
GVRShaderData mtl = getMaterial();
if ((mtl == null) ||
!mtl.getTextureDescriptor().contains("blendshapeTexture"))
{
throw new IllegalStateException("Scene object shader does not support morphing");
}
copyBaseShape(mesh.getVertexBuffer());
mtl.setInt("u_numblendshapes", mNumBlendShapes);
mtl.setFloatArray("u_blendweights", mWeights);
} | java |
protected boolean intersect(GVRSceneObject.BoundingVolume bv1, GVRSceneObject.BoundingVolume bv2)
{
return (bv1.maxCorner.x >= bv2.minCorner.x) &&
(bv1.maxCorner.y >= bv2.minCorner.y) &&
(bv1.maxCorner.z >= bv2.minCorner.z) &&
(bv1.minCorner.x <= bv2.maxCorner.x) &&
(bv1.minCorner.y <= bv2.maxCorner.y) &&
(bv1.minCorner.z <= bv2.maxCorner.z);
} | java |
public static GVRVideoSceneObjectPlayer<MediaPlayer> makePlayerInstance(final MediaPlayer mediaPlayer) {
return new GVRVideoSceneObjectPlayer<MediaPlayer>() {
@Override
public MediaPlayer getPlayer() {
return mediaPlayer;
}
@Override
public void setSurface(Surface surface) {
mediaPlayer.setSurface(surface);
}
@Override
public void release() {
mediaPlayer.release();
}
@Override
public boolean canReleaseSurfaceImmediately() {
return true;
}
@Override
public void pause() {
try {
mediaPlayer.pause();
} catch (final IllegalStateException exc) {
//intentionally ignored; might have been released already or never got to be
//initialized
}
}
@Override
public void start() {
mediaPlayer.start();
}
@Override
public boolean isPlaying() {
return mediaPlayer.isPlaying();
}
};
} | java |
public void setRefreshFrequency(IntervalFrequency frequency) {
if (NONE_REFRESH_INTERVAL == mRefreshInterval && IntervalFrequency.NONE != frequency) {
// Install draw-frame listener if frequency is no longer NONE
getGVRContext().unregisterDrawFrameListener(mFrameListener);
getGVRContext().registerDrawFrameListener(mFrameListener);
}
switch (frequency) {
case REALTIME:
mRefreshInterval = REALTIME_REFRESH_INTERVAL;
break;
case HIGH:
mRefreshInterval = HIGH_REFRESH_INTERVAL;
break;
case MEDIUM:
mRefreshInterval = MEDIUM_REFRESH_INTERVAL;
break;
case LOW:
mRefreshInterval = LOW_REFRESH_INTERVAL;
break;
case NONE:
mRefreshInterval = NONE_REFRESH_INTERVAL;
break;
default:
break;
}
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.