diff options
Diffstat (limited to 'libs')
34 files changed, 1183 insertions, 836 deletions
diff --git a/libs/audioflinger/AudioFlinger.cpp b/libs/audioflinger/AudioFlinger.cpp index 2024cc0..ecfe1e0 100644 --- a/libs/audioflinger/AudioFlinger.cpp +++ b/libs/audioflinger/AudioFlinger.cpp @@ -932,6 +932,8 @@ status_t AudioFlinger::PlaybackThread::dumpInternals(int fd, const Vector<String result.append(buffer); snprintf(buffer, SIZE, "blocked in write: %d\n", mInWrite); result.append(buffer); + snprintf(buffer, SIZE, "suspend count: %d\n", mSuspended); + result.append(buffer); write(fd, result.string(), result.size()); dumpBase(fd, args); @@ -1344,7 +1346,7 @@ uint32_t AudioFlinger::MixerThread::prepareTracks_l(const SortedVector< wp<Track if (cblk->framesReady() && (track->isReady() || track->isStopped()) && !track->isPaused()) { - //LOGV("track %d u=%08x, s=%08x [OK]", track->name(), cblk->user, cblk->server); + //LOGV("track %d u=%08x, s=%08x [OK] on thread %p", track->name(), cblk->user, cblk->server, this); // compute volume for this track int16_t left, right; @@ -1400,7 +1402,7 @@ uint32_t AudioFlinger::MixerThread::prepareTracks_l(const SortedVector< wp<Track track->mRetryCount = kMaxTrackRetries; mixerStatus = MIXER_TRACKS_READY; } else { - //LOGV("track %d u=%08x, s=%08x [NOT READY]", track->name(), cblk->user, cblk->server); + //LOGV("track %d u=%08x, s=%08x [NOT READY] on thread %p", track->name(), cblk->user, cblk->server, this); if (track->isStopped()) { track->reset(); } @@ -1914,7 +1916,7 @@ uint32_t AudioFlinger::DirectOutputThread::idleSleepTimeUs() // ---------------------------------------------------------------------------- AudioFlinger::DuplicatingThread::DuplicatingThread(const sp<AudioFlinger>& audioFlinger, AudioFlinger::MixerThread* mainThread, int id) - : MixerThread(audioFlinger, mainThread->getOutput(), id) + : MixerThread(audioFlinger, mainThread->getOutput(), id), mWaitTimeMs(UINT_MAX) { mType = PlaybackThread::DUPLICATING; addOutputTrack(mainThread); @@ -1952,6 +1954,7 @@ bool AudioFlinger::DuplicatingThread::threadLoop() if (checkForNewParameters_l()) { mixBufferSize = mFrameCount*mFrameSize; + updateWaitTime(); activeSleepTime = activeSleepTimeUs(); idleSleepTime = idleSleepTimeUs(); } @@ -2003,7 +2006,11 @@ bool AudioFlinger::DuplicatingThread::threadLoop() if (LIKELY(mixerStatus == MIXER_TRACKS_READY)) { // mix buffers... - mAudioMixer->process(curBuf); + if (outputsReady(outputTracks)) { + mAudioMixer->process(curBuf); + } else { + memset(curBuf, 0, mixBufferSize); + } sleepTime = 0; writeFrames = mFrameCount; } else { @@ -2054,6 +2061,7 @@ void AudioFlinger::DuplicatingThread::addOutputTrack(MixerThread *thread) { int frameCount = (3 * mFrameCount * mSampleRate) / thread->sampleRate(); OutputTrack *outputTrack = new OutputTrack((ThreadBase *)thread, + this, mSampleRate, mFormat, mChannelCount, @@ -2062,6 +2070,7 @@ void AudioFlinger::DuplicatingThread::addOutputTrack(MixerThread *thread) thread->setStreamVolume(AudioSystem::NUM_STREAM_TYPES, 1.0f); mOutputTracks.add(outputTrack); LOGV("addOutputTrack() track %p, on thread %p", outputTrack, thread); + updateWaitTime(); } } @@ -2072,12 +2081,50 @@ void AudioFlinger::DuplicatingThread::removeOutputTrack(MixerThread *thread) if (mOutputTracks[i]->thread() == (ThreadBase *)thread) { mOutputTracks[i]->destroy(); mOutputTracks.removeAt(i); + updateWaitTime(); return; } } LOGV("removeOutputTrack(): unkonwn thread: %p", thread); } +void AudioFlinger::DuplicatingThread::updateWaitTime() +{ + mWaitTimeMs = UINT_MAX; + for (size_t i = 0; i < mOutputTracks.size(); i++) { + sp<ThreadBase> strong = mOutputTracks[i]->thread().promote(); + if (strong != NULL) { + uint32_t waitTimeMs = (strong->frameCount() * 2 * 1000) / strong->sampleRate(); + if (waitTimeMs < mWaitTimeMs) { + mWaitTimeMs = waitTimeMs; + } + } + } +} + + +bool AudioFlinger::DuplicatingThread::outputsReady(SortedVector< sp<OutputTrack> > &outputTracks) +{ + for (size_t i = 0; i < outputTracks.size(); i++) { + sp <ThreadBase> thread = outputTracks[i]->thread().promote(); + if (thread == 0) { + LOGW("DuplicatingThread::outputsReady() could not promote thread on output track %p", outputTracks[i].get()); + return false; + } + PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); + if (playbackThread->standby() && !playbackThread->isSuspended()) { + LOGV("DuplicatingThread output track %p on thread %p Not Ready", outputTracks[i].get(), thread.get()); + return false; + } + } + return true; +} + +uint32_t AudioFlinger::DuplicatingThread::activeSleepTimeUs() +{ + return (mWaitTimeMs * 1000) / 2; +} + // ---------------------------------------------------------------------------- // TrackBase constructor must be called with AudioFlinger::mLock held @@ -2616,12 +2663,13 @@ void AudioFlinger::RecordThread::RecordTrack::dump(char* buffer, size_t size) AudioFlinger::PlaybackThread::OutputTrack::OutputTrack( const wp<ThreadBase>& thread, + DuplicatingThread *sourceThread, uint32_t sampleRate, int format, int channelCount, int frameCount) : Track(thread, NULL, AudioSystem::NUM_STREAM_TYPES, sampleRate, format, channelCount, frameCount, NULL), - mActive(false) + mActive(false), mSourceThread(sourceThread) { PlaybackThread *playbackThread = (PlaybackThread *)thread.unsafe_get(); @@ -2630,10 +2678,9 @@ AudioFlinger::PlaybackThread::OutputTrack::OutputTrack( mCblk->buffers = (char*)mCblk + sizeof(audio_track_cblk_t); mCblk->volume[0] = mCblk->volume[1] = 0x1000; mOutBuffer.frameCount = 0; - mWaitTimeMs = (playbackThread->frameCount() * 2 * 1000) / playbackThread->sampleRate(); playbackThread->mTracks.add(this); - LOGV("OutputTrack constructor mCblk %p, mBuffer %p, mCblk->buffers %p, mCblk->frameCount %d, mCblk->sampleRate %d, mCblk->channels %d mBufferEnd %p mWaitTimeMs %d", - mCblk, mBuffer, mCblk->buffers, mCblk->frameCount, mCblk->sampleRate, mCblk->channels, mBufferEnd, mWaitTimeMs); + LOGV("OutputTrack constructor mCblk %p, mBuffer %p, mCblk->buffers %p, mCblk->frameCount %d, mCblk->sampleRate %d, mCblk->channels %d mBufferEnd %p", + mCblk, mBuffer, mCblk->buffers, mCblk->frameCount, mCblk->sampleRate, mCblk->channels, mBufferEnd); } else { LOGW("Error creating output track on thread %p", playbackThread); } @@ -2673,7 +2720,7 @@ bool AudioFlinger::PlaybackThread::OutputTrack::write(int16_t* data, uint32_t fr inBuffer.frameCount = frames; inBuffer.i16 = data; - uint32_t waitTimeLeftMs = mWaitTimeMs; + uint32_t waitTimeLeftMs = mSourceThread->waitTimeMs(); if (!mActive && frames != 0) { start(); @@ -2712,12 +2759,11 @@ bool AudioFlinger::PlaybackThread::OutputTrack::write(int16_t* data, uint32_t fr mOutBuffer.frameCount = pInBuffer->frameCount; nsecs_t startTime = systemTime(); if (obtainBuffer(&mOutBuffer, waitTimeLeftMs) == (status_t)AudioTrack::NO_MORE_BUFFERS) { - LOGV ("OutputTrack::write() %p no more output buffers", this); + LOGV ("OutputTrack::write() %p thread %p no more output buffers", this, mThread.unsafe_get()); outputBufferFull = true; break; } uint32_t waitTimeMs = (uint32_t)ns2ms(systemTime() - startTime); - LOGV("OutputTrack::write() to thread %p waitTimeMs %d waitTimeLeftMs %d", mThread.unsafe_get(), waitTimeMs, waitTimeLeftMs); if (waitTimeLeftMs >= waitTimeMs) { waitTimeLeftMs -= waitTimeMs; } else { @@ -2738,7 +2784,7 @@ bool AudioFlinger::PlaybackThread::OutputTrack::write(int16_t* data, uint32_t fr mBufferQueue.removeAt(0); delete [] pInBuffer->mBuffer; delete pInBuffer; - LOGV("OutputTrack::write() %p released overflow buffer %d", this, mBufferQueue.size()); + LOGV("OutputTrack::write() %p thread %p released overflow buffer %d", this, mThread.unsafe_get(), mBufferQueue.size()); } else { break; } @@ -2747,16 +2793,19 @@ bool AudioFlinger::PlaybackThread::OutputTrack::write(int16_t* data, uint32_t fr // If we could not write all frames, allocate a buffer and queue it for next time. if (inBuffer.frameCount) { - if (mBufferQueue.size() < kMaxOverFlowBuffers) { - pInBuffer = new Buffer; - pInBuffer->mBuffer = new int16_t[inBuffer.frameCount * channels]; - pInBuffer->frameCount = inBuffer.frameCount; - pInBuffer->i16 = pInBuffer->mBuffer; - memcpy(pInBuffer->raw, inBuffer.raw, inBuffer.frameCount * channels * sizeof(int16_t)); - mBufferQueue.add(pInBuffer); - LOGV("OutputTrack::write() %p adding overflow buffer %d", this, mBufferQueue.size()); - } else { - LOGW("OutputTrack::write() %p no more overflow buffers", this); + sp<ThreadBase> thread = mThread.promote(); + if (thread != 0 && !thread->standby()) { + if (mBufferQueue.size() < kMaxOverFlowBuffers) { + pInBuffer = new Buffer; + pInBuffer->mBuffer = new int16_t[inBuffer.frameCount * channels]; + pInBuffer->frameCount = inBuffer.frameCount; + pInBuffer->i16 = pInBuffer->mBuffer; + memcpy(pInBuffer->raw, inBuffer.raw, inBuffer.frameCount * channels * sizeof(int16_t)); + mBufferQueue.add(pInBuffer); + LOGV("OutputTrack::write() %p thread %p adding overflow buffer %d", this, mThread.unsafe_get(), mBufferQueue.size()); + } else { + LOGW("OutputTrack::write() %p thread %p no more overflow buffers", mThread.unsafe_get(), this); + } } } diff --git a/libs/audioflinger/AudioFlinger.h b/libs/audioflinger/AudioFlinger.h index 8c29da8..12c90eb 100644 --- a/libs/audioflinger/AudioFlinger.h +++ b/libs/audioflinger/AudioFlinger.h @@ -20,6 +20,7 @@ #include <stdint.h> #include <sys/types.h> +#include <limits.h> #include <media/IAudioFlinger.h> #include <media/IAudioFlingerClient.h> @@ -208,6 +209,7 @@ private: class PlaybackThread; class MixerThread; class DirectOutputThread; + class DuplicatingThread; class Track; class RecordTrack; @@ -324,6 +326,7 @@ private: void sendConfigEvent_l(int event, int param = 0); void processConfigEvents(); int id() const { return mId;} + bool standby() { return mStandby; } mutable Mutex mLock; @@ -452,6 +455,7 @@ private: }; OutputTrack( const wp<ThreadBase>& thread, + DuplicatingThread *sourceThread, uint32_t sampleRate, int format, int channelCount, @@ -471,13 +475,12 @@ private: void clearBufferQueue(); // Maximum number of pending buffers allocated by OutputTrack::write() - static const uint8_t kMaxOverFlowBuffers = 3; + static const uint8_t kMaxOverFlowBuffers = 10; Vector < Buffer* > mBufferQueue; AudioBufferProvider::Buffer mOutBuffer; - uint32_t mWaitTimeMs; bool mActive; - + DuplicatingThread* mSourceThread; }; // end of OutputTrack PlaybackThread (const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id); @@ -520,6 +523,7 @@ private: virtual int type() const { return mType; } void suspend() { mSuspended++; } void restore() { if (mSuspended) mSuspended--; } + bool isSuspended() { return (mSuspended != 0); } virtual String8 getParameters(const String8& keys); virtual void audioConfigChanged(int event, int param = 0); @@ -635,9 +639,16 @@ private: virtual bool threadLoop(); void addOutputTrack(MixerThread* thread); void removeOutputTrack(MixerThread* thread); + uint32_t waitTimeMs() { return mWaitTimeMs; } + protected: + virtual uint32_t activeSleepTimeUs(); private: + bool outputsReady(SortedVector< sp<OutputTrack> > &outputTracks); + void updateWaitTime(); + SortedVector < sp<OutputTrack> > mOutputTracks; + uint32_t mWaitTimeMs; }; PlaybackThread *checkPlaybackThread_l(int output) const; diff --git a/libs/rs/Android.mk b/libs/rs/Android.mk index 111bdd4..3080ab0 100644 --- a/libs/rs/Android.mk +++ b/libs/rs/Android.mk @@ -76,6 +76,7 @@ ifneq ($(TARGET_SIMULATOR),true) LOCAL_SRC_FILES:= \ rsAdapter.cpp \ rsAllocation.cpp \ + rsComponent.cpp \ rsContext.cpp \ rsDevice.cpp \ rsElement.cpp \ diff --git a/libs/rs/RenderScript.h b/libs/rs/RenderScript.h index 44ff901..6662333 100644 --- a/libs/rs/RenderScript.h +++ b/libs/rs/RenderScript.h @@ -64,34 +64,53 @@ void rsContextInitToClient(RsContext); void rsContextDeinitToClient(RsContext); #define RS_MAX_TEXTURE 2 +#define RS_MAX_ATTRIBS 16 enum RsDataType { - RS_TYPE_FLOAT, - RS_TYPE_UNSIGNED, - RS_TYPE_SIGNED + RS_TYPE_NONE, + RS_TYPE_FLOAT_16, + RS_TYPE_FLOAT_32, + RS_TYPE_FLOAT_64, + RS_TYPE_SIGNED_8, + RS_TYPE_SIGNED_16, + RS_TYPE_SIGNED_32, + RS_TYPE_SIGNED_64, + RS_TYPE_UNSIGNED_8, + RS_TYPE_UNSIGNED_16, + RS_TYPE_UNSIGNED_32, + RS_TYPE_UNSIGNED_64, + + RS_TYPE_UNSIGNED_5_6_5, + RS_TYPE_UNSIGNED_5_5_5_1, + RS_TYPE_UNSIGNED_4_4_4_4, + + RS_TYPE_ELEMENT, + RS_TYPE_TYPE, + RS_TYPE_ALLOCATION, + RS_TYPE_SAMPLER, + RS_TYPE_SCRIPT, + RS_TYPE_MESH, + RS_TYPE_PROGRAM_FRAGMENT, + RS_TYPE_PROGRAM_VERTEX, + RS_TYPE_PROGRAM_RASTER, + RS_TYPE_PROGRAM_STORE }; enum RsDataKind { RS_KIND_USER, - RS_KIND_RED, - RS_KIND_GREEN, - RS_KIND_BLUE, - RS_KIND_ALPHA, - RS_KIND_LUMINANCE, - RS_KIND_INTENSITY, - RS_KIND_X, - RS_KIND_Y, - RS_KIND_Z, - RS_KIND_W, - RS_KIND_S, - RS_KIND_T, - RS_KIND_Q, - RS_KIND_R, - RS_KIND_NX, - RS_KIND_NY, - RS_KIND_NZ, + RS_KIND_COLOR, + RS_KIND_POSITION, + RS_KIND_TEXTURE, + RS_KIND_NORMAL, RS_KIND_INDEX, - RS_KIND_POINT_SIZE + RS_KIND_POINT_SIZE, + + RS_KIND_PIXEL_L, + RS_KIND_PIXEL_A, + RS_KIND_PIXEL_LA, + RS_KIND_PIXEL_RGB, + RS_KIND_PIXEL_RGBA, + }; enum RsSamplerParam { @@ -158,6 +177,7 @@ enum RsBlendDstFunc { }; enum RsTexEnvMode { + RS_TEX_ENV_MODE_NONE, RS_TEX_ENV_MODE_REPLACE, RS_TEX_ENV_MODE_MODULATE, RS_TEX_ENV_MODE_DECAL diff --git a/libs/rs/java/Film/Android.mk b/libs/rs/java/Film/Android.mk index b7f98fc..9e6ed7e 100644 --- a/libs/rs/java/Film/Android.mk +++ b/libs/rs/java/Film/Android.mk @@ -17,6 +17,8 @@ LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) +LOCAL_MODULE_TAGS := optional + LOCAL_SRC_FILES := $(call all-java-files-under, src) #LOCAL_STATIC_JAVA_LIBRARIES := android.renderscript diff --git a/libs/rs/java/Film/src/com/android/film/FilmRS.java b/libs/rs/java/Film/src/com/android/film/FilmRS.java index 3b93c18..b80e619 100644 --- a/libs/rs/java/Film/src/com/android/film/FilmRS.java +++ b/libs/rs/java/Film/src/com/android/film/FilmRS.java @@ -121,13 +121,13 @@ public class FilmRS { bs.setWrapT(Sampler.Value.WRAP); mSampler = bs.create(); - ProgramFragment.Builder b = new ProgramFragment.Builder(mRS, null, null); - + ProgramFragment.Builder b = new ProgramFragment.Builder(mRS); mPFBackground = b.create(); mPFBackground.setName("PFBackground"); - b.setTexEnable(true, 0); - b.setTexEnvMode(ProgramFragment.EnvMode.REPLACE, 0); + b = new ProgramFragment.Builder(mRS); + b.setTexture(ProgramFragment.Builder.EnvMode.REPLACE, + ProgramFragment.Builder.Format.RGBA, 0); mPFImages = b.create(); mPFImages.bindSampler(mSampler, 0); mPFImages.setName("PFImages"); @@ -152,9 +152,10 @@ public class FilmRS { mBufferIDs = new int[13]; mImages = new Allocation[13]; mAllocIDs = Allocation.createSized(mRS, - Element.USER_F32(mRS), mBufferIDs.length); + Element.createUser(mRS, Element.DataType.FLOAT_32), + mBufferIDs.length); - Element ie = Element.RGB_565(mRS); + Element ie = Element.createPixel(mRS, Element.DataType.UNSIGNED_5_6_5, Element.DataKind.PIXEL_RGB); mImages[0] = Allocation.createFromBitmapResourceBoxed(mRS, mRes, R.drawable.p01, ie, true); mImages[1] = Allocation.createFromBitmapResourceBoxed(mRS, mRes, R.drawable.p02, ie, true); mImages[2] = Allocation.createFromBitmapResourceBoxed(mRS, mRes, R.drawable.p03, ie, true); @@ -195,7 +196,8 @@ public class FilmRS { { mBufferState = new int[10]; mAllocState = Allocation.createSized(mRS, - Element.USER_F32(mRS), mBufferState.length); + Element.createUser(mRS, Element.DataType.FLOAT_32), + mBufferState.length); mBufferState[STATE_LAST_FOCUS] = -1; mAllocState.data(mBufferState); } @@ -238,12 +240,12 @@ public class FilmRS { mAllocOffsets = Allocation.createSized(mRS, - Element.USER_I32(mRS), mFSM.mTriangleOffsets.length); + Element.createUser(mRS, Element.DataType.SIGNED_32), mFSM.mTriangleOffsets.length); mAllocOffsets.data(mFSM.mTriangleOffsets); mScriptStrip.bindAllocation(mAllocOffsets, 4); mAllocOffsetsTex = Allocation.createSized(mRS, - Element.USER_F32(mRS), mFSM.mTriangleOffsetsTex.length); + Element.createUser(mRS, Element.DataType.FLOAT_32), mFSM.mTriangleOffsetsTex.length); mAllocOffsetsTex.data(mFSM.mTriangleOffsetsTex); mScriptStrip.bindAllocation(mAllocOffsetsTex, 5); diff --git a/libs/rs/java/Fountain/Android.mk b/libs/rs/java/Fountain/Android.mk index b6a9f10..f7e53a8 100644 --- a/libs/rs/java/Fountain/Android.mk +++ b/libs/rs/java/Fountain/Android.mk @@ -17,6 +17,8 @@ LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) +LOCAL_MODULE_TAGS := optional + LOCAL_SRC_FILES := $(call all-java-files-under, src) #LOCAL_STATIC_JAVA_LIBRARIES := android.renderscript diff --git a/libs/rs/java/Fountain/res/raw/fountain.c b/libs/rs/java/Fountain/res/raw/fountain.c index f218f9b..73b819b 100644 --- a/libs/rs/java/Fountain/res/raw/fountain.c +++ b/libs/rs/java/Fountain/res/raw/fountain.c @@ -14,19 +14,17 @@ int main(int launchID) { float rMax = ((float)rate) * 0.005f; int x = Control->x; int y = Control->y; - char r = Control->r * 255.f; - char g = Control->g * 255.f; - char b = Control->b * 255.f; + int color = ((int)(Control->r * 255.f)) | + ((int)(Control->g * 255.f)) << 8 | + ((int)(Control->b * 255.f)) << 16 | + (0xf0 << 24); struct point_s * np = &p[newPart]; while (rate--) { - vec2Rand((float *)np, rMax); - np->x = x; - np->y = y; - np->r = r; - np->g = g; - np->b = b; - np->a = 0xf0; + vec2Rand((float *)&np->delta.x, rMax); + np->position.x = x; + np->position.y = y; + np->color = color; newPart++; np++; if (newPart >= count) { @@ -37,14 +35,14 @@ int main(int launchID) { } for (ct=0; ct < count; ct++) { - float dy = p->dy + 0.15f; - float posy = p->y + dy; + float dy = p->delta.y + 0.15f; + float posy = p->position.y + dy; if ((posy > height) && (dy > 0)) { dy *= -0.3f; } - p->dy = dy; - p->x += p->dx; - p->y = posy; + p->delta.y = dy; + p->position.x += p->delta.x; + p->position.y = posy; p++; } diff --git a/libs/rs/java/Fountain/src/com/android/fountain/FountainRS.java b/libs/rs/java/Fountain/src/com/android/fountain/FountainRS.java index f4f9b0c..71f95a7 100644 --- a/libs/rs/java/Fountain/src/com/android/fountain/FountainRS.java +++ b/libs/rs/java/Fountain/src/com/android/fountain/FountainRS.java @@ -79,10 +79,9 @@ public class FountainRS { mIntAlloc.data(mSD); Element.Builder eb = new Element.Builder(mRS); - eb.addFloat(Element.DataKind.USER, "dx"); - eb.addFloat(Element.DataKind.USER, "dy"); - eb.addFloatXY(""); - eb.addUNorm8RGBA(""); + eb.add(Element.createVector(mRS, Element.DataType.FLOAT_32, 2), "delta"); + eb.add(Element.createAttrib(mRS, Element.DataType.FLOAT_32, Element.DataKind.POSITION, 2), "position"); + eb.add(Element.createAttrib(mRS, Element.DataType.UNSIGNED_8, Element.DataKind.COLOR, 4), "color"); Element primElement = eb.create(); diff --git a/libs/rs/java/ImageProcessing/Android.mk b/libs/rs/java/ImageProcessing/Android.mk index 5a844d5..833427b 100644 --- a/libs/rs/java/ImageProcessing/Android.mk +++ b/libs/rs/java/ImageProcessing/Android.mk @@ -17,6 +17,8 @@ LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) +LOCAL_MODULE_TAGS := optional + LOCAL_SRC_FILES := $(call all-java-files-under, src) #LOCAL_STATIC_JAVA_LIBRARIES := android.renderscript diff --git a/libs/rs/java/ImageProcessing/src/com/android/rs/image/ImageProcessingActivity.java b/libs/rs/java/ImageProcessing/src/com/android/rs/image/ImageProcessingActivity.java index 334fd9c..0ca00b3 100644 --- a/libs/rs/java/ImageProcessing/src/com/android/rs/image/ImageProcessingActivity.java +++ b/libs/rs/java/ImageProcessing/src/com/android/rs/image/ImageProcessingActivity.java @@ -62,7 +62,7 @@ public class ImageProcessingActivity extends Activity implements SurfaceHolder.C public float threshold; } - + static class Pixel { public byte a; public byte r; @@ -78,7 +78,7 @@ public class ImageProcessingActivity extends Activity implements SurfaceHolder.C mParams.outWidth, mParams.outHeight); mDisplayView.invalidate(); } - }; + }; @Override public void run() { @@ -131,7 +131,7 @@ public class ImageProcessingActivity extends Activity implements SurfaceHolder.C public void surfaceDestroyed(SurfaceHolder holder) { } - + private Script.Invokable createScript() { mRS = new RenderScript(false, false); mRS.mMessageCallback = new FilterCallback(); @@ -143,9 +143,11 @@ public class ImageProcessingActivity extends Activity implements SurfaceHolder.C final int pixelCount = mParams.inWidth * mParams.inHeight; mPixelType = Type.createFromClass(mRS, Pixel.class, 1, "Pixel"); - mInPixelsAllocation = Allocation.createSized(mRS, Element.USER_I32(mRS), + mInPixelsAllocation = Allocation.createSized(mRS, + Element.createUser(mRS, Element.DataType.SIGNED_32), pixelCount); - mOutPixelsAllocation = Allocation.createSized(mRS, Element.USER_I32(mRS), + mOutPixelsAllocation = Allocation.createSized(mRS, + Element.createUser(mRS, Element.DataType.SIGNED_32), pixelCount); final int[] data = new int[pixelCount]; @@ -154,7 +156,7 @@ public class ImageProcessingActivity extends Activity implements SurfaceHolder.C mOutData = new int[pixelCount]; mOutPixelsAllocation.data(mOutData); - + ScriptC.Builder sb = new ScriptC.Builder(mRS); sb.setType(mParamsType, "Params", 0); sb.setType(mPixelType, "InPixel", 1); diff --git a/libs/rs/rs.spec b/libs/rs/rs.spec index 5de76b2..ac115d3 100644 --- a/libs/rs/rs.spec +++ b/libs/rs/rs.spec @@ -20,16 +20,6 @@ ContextBindProgramRaster { param RsProgramRaster pgm } -ContextSetDefineF { - param const char* name - param float value - } - -ContextSetDefineI32 { - param const char* name - param int32_t value - } - ContextPause { } @@ -60,18 +50,19 @@ ObjDestroy { param void *obj } -ElementBegin { -} - -ElementAdd { - param RsDataKind dataKind - param RsDataType dataType - param bool isNormalized - param size_t bits - param const char * name +ElementCreate { + param RsDataType mType + param RsDataKind mKind + param bool mNormalized + param uint32_t mVectorSize + ret RsElement } -ElementCreate { +ElementCreate2 { + param size_t count + param const RsElement * elements + param const char ** names + param const size_t * nameLengths ret RsElement } @@ -372,37 +363,22 @@ ProgramBindConstants { param RsAllocation constants } -ProgramFragmentBegin { - param RsElement in - param RsElement out - param bool pointSpriteEnable - } - -ProgramFragmentSetShader { - param const char * text - param uint32_t length - } -ProgramFragmentBindTexture { +ProgramBindTexture { param RsProgramFragment pf param uint32_t slot param RsAllocation a } -ProgramFragmentBindSampler { +ProgramBindSampler { param RsProgramFragment pf param uint32_t slot param RsSampler s } -ProgramFragmentSetSlot { - param uint32_t slot - param bool enable - param RsTexEnvMode env - param RsType t - } - ProgramFragmentCreate { + param const uint32_t * params + param uint32_t paramLength ret RsProgramFragment } diff --git a/libs/rs/rsAllocation.cpp b/libs/rs/rsAllocation.cpp index 7f76390..b4ec1a2 100644 --- a/libs/rs/rsAllocation.cpp +++ b/libs/rs/rsAllocation.cpp @@ -106,8 +106,8 @@ void Allocation::uploadToTexture(const Context *rsc) return; } - GLenum type = mType->getElement()->getGLType(); - GLenum format = mType->getElement()->getGLFormat(); + GLenum type = mType->getElement()->getComponent().getGLType(); + GLenum format = mType->getElement()->getComponent().getGLFormat(); if (!type || !format) { return; @@ -422,10 +422,10 @@ static void elementConverter_8888_to_565(void *dst, const void *src, uint32_t co static ElementConverter_t pickConverter(const Element *dst, const Element *src) { - GLenum srcGLType = src->getGLType(); - GLenum srcGLFmt = src->getGLFormat(); - GLenum dstGLType = dst->getGLType(); - GLenum dstGLFmt = dst->getGLFormat(); + GLenum srcGLType = src->getComponent().getGLType(); + GLenum srcGLFmt = src->getComponent().getGLFormat(); + GLenum dstGLType = dst->getComponent().getGLType(); + GLenum dstGLFmt = dst->getComponent().getGLFormat(); if (srcGLFmt == dstGLFmt && srcGLType == dstGLType) { switch(dst->getSizeBytes()) { @@ -463,8 +463,9 @@ RsAllocation rsi_AllocationCreateFromBitmap(Context *rsc, uint32_t w, uint32_t h { const Element *src = static_cast<const Element *>(_src); const Element *dst = static_cast<const Element *>(_dst); - rsAssert(!(w & (w-1))); - rsAssert(!(h & (h-1))); + + // Check for pow2 on pre es 2.0 versions. + rsAssert(rsc->checkVersion2_0() || (!(w & (w-1)) && !(h & (h-1)))); //LOGE("rsi_AllocationCreateFromBitmap %i %i %i %i %i", w, h, dstFmt, srcFmt, genMips); rsi_TypeBegin(rsc, _dst); diff --git a/libs/rs/rsComponent.cpp b/libs/rs/rsComponent.cpp new file mode 100644 index 0000000..15a56f7 --- /dev/null +++ b/libs/rs/rsComponent.cpp @@ -0,0 +1,337 @@ +/* + * Copyright (C) 2009 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "rsComponent.h" + +#include <GLES/gl.h> + +using namespace android; +using namespace android::renderscript; + +Component::Component() +{ + set(RS_TYPE_NONE, RS_KIND_USER, false, 1); +} + +Component::~Component() +{ +} + +void Component::set(RsDataType dt, RsDataKind dk, bool norm, uint32_t vecSize) +{ + mType = dt; + mKind = dk; + mNormalized = norm; + mVectorSize = vecSize; + rsAssert(vecSize <= 4); + + mBits = 0; + mTypeBits = 0; + mIsFloat = false; + mIsSigned = false; + mIsPixel = false; + + switch(mKind) { + case RS_KIND_PIXEL_L: + case RS_KIND_PIXEL_A: + mIsPixel = true; + rsAssert(mVectorSize == 1); + rsAssert(mNormalized == true); + break; + case RS_KIND_PIXEL_LA: + mIsPixel = true; + rsAssert(mVectorSize == 2); + rsAssert(mNormalized == true); + break; + case RS_KIND_PIXEL_RGB: + mIsPixel = true; + rsAssert(mVectorSize == 3); + rsAssert(mNormalized == true); + break; + case RS_KIND_PIXEL_RGBA: + mIsPixel = true; + rsAssert(mVectorSize == 4); + rsAssert(mNormalized == true); + break; + default: + break; + } + + switch(mType) { + case RS_TYPE_NONE: + return; + case RS_TYPE_UNSIGNED_5_6_5: + mVectorSize = 3; + mBits = 16; + mNormalized = true; + rsAssert(mKind == RS_KIND_PIXEL_RGB); + return; + case RS_TYPE_UNSIGNED_5_5_5_1: + mVectorSize = 4; + mBits = 16; + mNormalized = true; + rsAssert(mKind == RS_KIND_PIXEL_RGBA); + return; + case RS_TYPE_UNSIGNED_4_4_4_4: + mVectorSize = 4; + mBits = 16; + mNormalized = true; + rsAssert(mKind == RS_KIND_PIXEL_RGBA); + return; + case RS_TYPE_ELEMENT: + case RS_TYPE_TYPE: + case RS_TYPE_ALLOCATION: + case RS_TYPE_SAMPLER: + case RS_TYPE_SCRIPT: + case RS_TYPE_MESH: + case RS_TYPE_PROGRAM_FRAGMENT: + case RS_TYPE_PROGRAM_VERTEX: + case RS_TYPE_PROGRAM_RASTER: + case RS_TYPE_PROGRAM_STORE: + rsAssert(mVectorSize == 1); + rsAssert(mNormalized == false); + rsAssert(mKind == RS_KIND_USER); + mBits = 32; + mTypeBits = 32; + return; + + case RS_TYPE_FLOAT_16: + mTypeBits = 16; + mIsFloat = true; + break; + case RS_TYPE_FLOAT_32: + mTypeBits = 32; + mIsFloat = true; + break; + case RS_TYPE_FLOAT_64: + mTypeBits = 64; + mIsFloat = true; + break; + case RS_TYPE_SIGNED_8: + mTypeBits = 8; + mIsSigned = true; + break; + case RS_TYPE_SIGNED_16: + mTypeBits = 16; + mIsSigned = true; + break; + case RS_TYPE_SIGNED_32: + mTypeBits = 32; + mIsSigned = true; + break; + case RS_TYPE_SIGNED_64: + mTypeBits = 64; + mIsSigned = true; + break; + case RS_TYPE_UNSIGNED_8: + mTypeBits = 8; + break; + case RS_TYPE_UNSIGNED_16: + mTypeBits = 16; + break; + case RS_TYPE_UNSIGNED_32: + mTypeBits = 32; + break; + case RS_TYPE_UNSIGNED_64: + mTypeBits = 64; + break; + } + + mBits = mTypeBits * mVectorSize; +} + + + + +uint32_t Component::getGLType() const +{ + switch (mType) { + case RS_TYPE_UNSIGNED_5_6_5: return GL_UNSIGNED_SHORT_5_6_5; + case RS_TYPE_UNSIGNED_5_5_5_1: return GL_UNSIGNED_SHORT_5_5_5_1; + case RS_TYPE_UNSIGNED_4_4_4_4: return GL_UNSIGNED_SHORT_4_4_4_4; + + //case RS_TYPE_FLOAT_16: return GL_HALF_FLOAT; + case RS_TYPE_FLOAT_32: return GL_FLOAT; + case RS_TYPE_UNSIGNED_8: return GL_UNSIGNED_BYTE; + case RS_TYPE_UNSIGNED_16: return GL_UNSIGNED_SHORT; + case RS_TYPE_SIGNED_8: return GL_BYTE; + case RS_TYPE_SIGNED_16: return GL_SHORT; + default: break; + } + + return 0; +} + +uint32_t Component::getGLFormat() const +{ + switch (mKind) { + case RS_KIND_PIXEL_L: return GL_LUMINANCE; + case RS_KIND_PIXEL_A: return GL_ALPHA; + case RS_KIND_PIXEL_LA: return GL_LUMINANCE_ALPHA; + case RS_KIND_PIXEL_RGB: return GL_RGB; + case RS_KIND_PIXEL_RGBA: return GL_RGBA; + default: break; + } + return 0; +} + +static const char * gCTypeStrings[] = { + 0, + 0,//"F16", + "float", + "double", + "char", + "short", + "int", + 0,//"S64", + "char",//U8", + "short",//U16", + "int",//U32", + 0,//"U64", + 0,//"UP_565", + 0,//"UP_5551", + 0,//"UP_4444", + 0,//"ELEMENT", + 0,//"TYPE", + 0,//"ALLOCATION", + 0,//"SAMPLER", + 0,//"SCRIPT", + 0,//"MESH", + 0,//"PROGRAM_FRAGMENT", + 0,//"PROGRAM_VERTEX", + 0,//"PROGRAM_RASTER", + 0,//"PROGRAM_STORE", +}; + +static const char * gCVecTypeStrings[] = { + 0, + 0,//"F16", + "vecF32", + "vecF64", + "vecI8", + "vecI16", + "vecI32", + 0,//"S64", + "vecU8",//U8", + "vecU16",//U16", + "vecU32",//U32", + 0,//"U64", + 0,//"UP_565", + 0,//"UP_5551", + 0,//"UP_4444", + 0,//"ELEMENT", + 0,//"TYPE", + 0,//"ALLOCATION", + 0,//"SAMPLER", + 0,//"SCRIPT", + 0,//"MESH", + 0,//"PROGRAM_FRAGMENT", + 0,//"PROGRAM_VERTEX", + 0,//"PROGRAM_RASTER", + 0,//"PROGRAM_STORE", +}; + +String8 Component::getCType() const +{ + char buf[64]; + if (mVectorSize == 1) { + return String8(gCTypeStrings[mType]); + } + + // Yuck, acc WAR + // Appears to have problems packing chars + if (mVectorSize == 4 && mType == RS_TYPE_UNSIGNED_8) { + return String8("int"); + } + + + String8 s(gCVecTypeStrings[mType]); + sprintf(buf, "_%i_t", mVectorSize); + s.append(buf); + return s; +} + +String8 Component::getGLSLType() const +{ + if (mType == RS_TYPE_SIGNED_32) { + switch(mVectorSize) { + case 1: return String8("int"); + case 2: return String8("ivec2"); + case 3: return String8("ivec3"); + case 4: return String8("ivec4"); + } + } + if (mType == RS_TYPE_FLOAT_32) { + switch(mVectorSize) { + case 1: return String8("float"); + case 2: return String8("vec2"); + case 3: return String8("vec3"); + case 4: return String8("vec4"); + } + } + return String8(); +} + +static const char * gTypeStrings[] = { + "NONE", + "F16", + "F32", + "F64", + "S8", + "S16", + "S32", + "S64", + "U8", + "U16", + "U32", + "U64", + "UP_565", + "UP_5551", + "UP_4444", + "ELEMENT", + "TYPE", + "ALLOCATION", + "SAMPLER", + "SCRIPT", + "MESH", + "PROGRAM_FRAGMENT", + "PROGRAM_VERTEX", + "PROGRAM_RASTER", + "PROGRAM_STORE", +}; + +static const char * gKindStrings[] = { + "USER", + "COLOR", + "POSITION", + "TEXTURE", + "NORMAL", + "INDEX", + "POINT_SIZE", + "PIXEL_L", + "PIXEL_A", + "PIXEL_LA", + "PIXEL_RGB", + "PIXEL_RGBA", +}; + +void Component::dumpLOGV(const char *prefix) const +{ + LOGV("%s Component: %s, %s, vectorSize=%i, bits=%i", + prefix, gTypeStrings[mType], gKindStrings[mKind], mVectorSize, mBits); +} + + diff --git a/libs/rs/rsComponent.h b/libs/rs/rsComponent.h new file mode 100644 index 0000000..71de324 --- /dev/null +++ b/libs/rs/rsComponent.h @@ -0,0 +1,69 @@ +/* + * Copyright (C) 2009 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ANDROID_COMPONENT_H +#define ANDROID_COMPONENT_H + +#include "rsUtils.h" + +// --------------------------------------------------------------------------- +namespace android { +namespace renderscript { + + +// An element is a group of Components that occupies one cell in a structure. +class Component +{ +public: + Component(); + ~Component(); + + void set(RsDataType dt, RsDataKind dk, bool norm, uint32_t vecSize=1); + + uint32_t getGLType() const; + uint32_t getGLFormat() const; + String8 getCType() const; + String8 getGLSLType() const; + void dumpLOGV(const char *prefix) const; + + + RsDataType getType() const {return mType;} + RsDataKind getKind() const {return mKind;} + bool getIsNormalized() const {return mNormalized;} + uint32_t getVectorSize() const {return mVectorSize;} + bool getIsFloat() const {return mIsFloat;} + bool getIsSigned() const {return mIsSigned;} + uint32_t getBits() const {return mBits;} + +protected: + RsDataType mType; + RsDataKind mKind; + bool mNormalized; + uint32_t mVectorSize; + + // derived + uint32_t mBits; + uint32_t mTypeBits; + bool mIsFloat; + bool mIsSigned; + bool mIsPixel; +}; + +} +} + +#endif + diff --git a/libs/rs/rsContext.cpp b/libs/rs/rsContext.cpp index 8f56efa..261b827 100644 --- a/libs/rs/rsContext.cpp +++ b/libs/rs/rsContext.cpp @@ -142,6 +142,13 @@ uint32_t Context::runScript(Script *s, uint32_t launchID) return ret; } +void Context::checkError(const char *msg) const +{ + GLenum err = glGetError(); + if (err != GL_NO_ERROR) { + LOGE("GL Error, 0x%x, from %s", err, msg); + } +} uint32_t Context::runRootScript() { @@ -169,11 +176,7 @@ uint32_t Context::runRootScript() mStateFragmentStore.mLast.clear(); uint32_t ret = runScript(mRootScript.get(), 0); - GLenum err = glGetError(); - if (err != GL_NO_ERROR) { - LOGE("Pending GL Error, 0x%x", err); - } - + checkError("runRootScript"); return ret; } @@ -271,8 +274,8 @@ void * Context::threadProc(void *vrsc) rsc->props.mLogTimes = getProp("debug.rs.profile"); rsc->props.mLogScripts = getProp("debug.rs.script"); - rsc->props.mLogObjects = getProp("debug.rs.objects"); - rsc->props.mLogShaders = getProp("debug.rs.shaders"); + rsc->props.mLogObjects = getProp("debug.rs.object"); + rsc->props.mLogShaders = getProp("debug.rs.shader"); ScriptTLSStruct *tlsStruct = new ScriptTLSStruct; if (!tlsStruct) { @@ -340,10 +343,6 @@ void * Context::threadProc(void *vrsc) rsc->mObjDestroy.mNeedToEmpty = true; rsc->objDestroyOOBRun(); - glClearColor(0,0,0,0); - glClear(GL_COLOR_BUFFER_BIT); - eglSwapBuffers(rsc->mEGL.mDisplay, rsc->mEGL.mSurface); - pthread_mutex_lock(&gInitMutex); rsc->deinitEGL(); pthread_mutex_unlock(&gInitMutex); @@ -633,26 +632,6 @@ void Context::appendNameDefines(String8 *str) const } } -void Context::appendVarDefines(String8 *str) const -{ - char buf[256]; - for (size_t ct=0; ct < mInt32Defines.size(); ct++) { - str->append("#define "); - str->append(mInt32Defines.keyAt(ct)); - str->append(" "); - sprintf(buf, "%i\n", (int)mInt32Defines.valueAt(ct)); - str->append(buf); - - } - for (size_t ct=0; ct < mFloatDefines.size(); ct++) { - str->append("#define "); - str->append(mFloatDefines.keyAt(ct)); - str->append(" "); - sprintf(buf, "%ff\n", mFloatDefines.valueAt(ct)); - str->append(buf); - } -} - bool Context::objDestroyOOBInit() { int status = pthread_mutex_init(&mObjDestroy.mMutex, NULL); @@ -852,16 +831,6 @@ void rsi_ObjDestroy(Context *rsc, void *obj) ob->decUserRef(); } -void rsi_ContextSetDefineF(Context *rsc, const char* name, float value) -{ - rsc->addInt32Define(name, value); -} - -void rsi_ContextSetDefineI32(Context *rsc, const char* name, int32_t value) -{ - rsc->addFloatDefine(name, value); -} - void rsi_ContextPause(Context *rsc) { rsc->pause(); diff --git a/libs/rs/rsContext.h b/libs/rs/rsContext.h index dd0423e..2edd16d 100644 --- a/libs/rs/rsContext.h +++ b/libs/rs/rsContext.h @@ -105,7 +105,6 @@ public: void removeName(ObjectBase *obj); ObjectBase * lookupName(const char *name) const; void appendNameDefines(String8 *str) const; - void appendVarDefines(String8 *str) const; uint32_t getMessageToClient(void *data, size_t *receiveLen, size_t bufferLen, bool wait); bool sendMessageToClient(void *data, uint32_t cmdID, size_t len, bool waitForSpace); @@ -127,14 +126,6 @@ public: return mStateRaster.mDefault.get(); } - void addInt32Define(const char* name, int32_t value) { - mInt32Defines.add(String8(name), value); - } - - void addFloatDefine(const char* name, float value) { - mFloatDefines.add(String8(name), value); - } - uint32_t getWidth() const {return mEGL.mWidth;} uint32_t getHeight() const {return mEGL.mHeight;} @@ -168,6 +159,7 @@ public: } props; void dumpDebug() const; + void checkError(const char *) const; mutable const ObjectBase * mObjHead; @@ -248,8 +240,6 @@ private: Surface *mWndSurface; Vector<ObjectBase *> mNames; - KeyedVector<String8,int> mInt32Defines; - KeyedVector<String8,float> mFloatDefines; uint64_t mTimers[_RS_TIMER_TOTAL]; Timers mTimerActive; diff --git a/libs/rs/rsElement.cpp b/libs/rs/rsElement.cpp index e796556..207ad15 100644 --- a/libs/rs/rsElement.cpp +++ b/libs/rs/rsElement.cpp @@ -24,9 +24,6 @@ using namespace android::renderscript; Element::Element(Context *rsc) : ObjectBase(rsc) { - mType = RS_TYPE_FLOAT; - mIsNormalized = false; - mKind = RS_KIND_USER; mBits = 0; mAllocFile = __FILE__; mAllocLine = __LINE__; @@ -46,17 +43,6 @@ void Element::clear() mFields = NULL; mFieldCount = 0; } -/* -void Element::setComponent(uint32_t idx, Component *c) -{ - rsAssert(!mComponents[idx].get()); - rsAssert(idx < mComponentCount); - mComponents[idx].set(c); - -// Fixme: This should probably not be here - c->incUserRef(); -} -*/ size_t Element::getSizeBits() const { @@ -80,161 +66,6 @@ size_t Element::getFieldOffsetBits(uint32_t componentNumber) const return offset; } -uint32_t Element::getGLType() const -{ - int bits[4]; - - if (!mFieldCount) { - switch (mType) { - case RS_TYPE_FLOAT: - if (mBits == 32) { - return GL_FLOAT; - } - return 0; - case RS_TYPE_SIGNED: - switch (mBits) { - case 8: - return GL_BYTE; - case 16: - return GL_SHORT; - //case 32: - //return GL_INT; - } - return 0; - case RS_TYPE_UNSIGNED: - switch (mBits) { - case 8: - return GL_UNSIGNED_BYTE; - case 16: - return GL_UNSIGNED_SHORT; - //case 32: - //return GL_UNSIGNED_INT; - } - return 0; - } - } - - if (mFieldCount > 4) { - return 0; - } - - for (uint32_t ct=0; ct < mFieldCount; ct++) { - bits[ct] = mFields[ct].e->mBits; - if (mFields[ct].e->mFieldCount) { - return 0; - } - if (mFields[ct].e->mType != RS_TYPE_UNSIGNED) { - return 0; - } - if (!mFields[ct].e->mIsNormalized) { - return 0; - } - } - - switch(mFieldCount) { - case 1: - if (bits[0] == 8) { - return GL_UNSIGNED_BYTE; - } - return 0; - case 2: - if ((bits[0] == 8) && - (bits[1] == 8)) { - return GL_UNSIGNED_BYTE; - } - return 0; - case 3: - if ((bits[0] == 8) && - (bits[1] == 8) && - (bits[2] == 8)) { - return GL_UNSIGNED_BYTE; - } - if ((bits[0] == 5) && - (bits[1] == 6) && - (bits[2] == 5)) { - return GL_UNSIGNED_SHORT_5_6_5; - } - return 0; - case 4: - if ((bits[0] == 8) && - (bits[1] == 8) && - (bits[2] == 8) && - (bits[3] == 8)) { - return GL_UNSIGNED_BYTE; - } - if ((bits[0] == 4) && - (bits[1] == 4) && - (bits[2] == 4) && - (bits[3] == 4)) { - return GL_UNSIGNED_SHORT_4_4_4_4; - } - if ((bits[0] == 5) && - (bits[1] == 5) && - (bits[2] == 5) && - (bits[3] == 1)) { - return GL_UNSIGNED_SHORT_5_5_5_1; - } - } - return 0; -} - -uint32_t Element::getGLFormat() const -{ - if (!mFieldCount) { - if (mKind == RS_KIND_ALPHA) { - return GL_ALPHA; - } - if (mKind == RS_KIND_LUMINANCE) { - return GL_LUMINANCE; - } - } - - switch(mFieldCount) { - case 2: - if ((mFields[0].e->mKind == RS_KIND_LUMINANCE) && - (mFields[1].e->mKind == RS_KIND_ALPHA)) { - return GL_LUMINANCE_ALPHA; - } - break; - case 3: - if ((mFields[0].e->mKind == RS_KIND_RED) && - (mFields[1].e->mKind == RS_KIND_GREEN) && - (mFields[2].e->mKind == RS_KIND_BLUE)) { - return GL_RGB; - } - break; - case 4: - if ((mFields[0].e->mKind == RS_KIND_RED) && - (mFields[1].e->mKind == RS_KIND_GREEN) && - (mFields[2].e->mKind == RS_KIND_BLUE) && - (mFields[3].e->mKind == RS_KIND_ALPHA)) { - return GL_RGBA; - } - break; - } - return 0; -} - -const char * Element::getCType() const -{ - switch(mType) { - case RS_TYPE_FLOAT: - return "float"; - case RS_TYPE_SIGNED: - case RS_TYPE_UNSIGNED: - switch(mBits) { - case 32: - return "int"; - case 16: - return "short"; - case 8: - return "char"; - } - break; - } - return NULL; -} - void Element::dumpLOGV(const char *prefix) const { ObjectBase::dumpLOGV(prefix); @@ -246,19 +77,18 @@ void Element::dumpLOGV(const char *prefix) const } } -Element * Element::create(Context *rsc, RsDataKind dk, RsDataType dt, - bool isNorm, size_t bits) + +Element * Element::create(Context *rsc, RsDataType dt, RsDataKind dk, + bool isNorm, uint32_t vecSize) { Element *e = new Element(rsc); - e->mKind = dk; - e->mType = dt; - e->mIsNormalized = isNorm; - e->mBits = bits; + e->mComponent.set(dt, dk, isNorm, vecSize); + e->mBits = e->mComponent.getBits(); return e; } -Element * Element::create(Context *rsc, Element **ein, const char **nin, - const size_t * lengths, size_t count) +Element * Element::create(Context *rsc, size_t count, const Element **ein, + const char **nin, const size_t * lengths) { Element *e = new Element(rsc); e->mFields = new ElementField_t [count]; @@ -272,78 +102,103 @@ Element * Element::create(Context *rsc, Element **ein, const char **nin, return e; } - -ElementState::ElementState() +String8 Element::getCStructBody(uint32_t indent) const { -} + String8 si; + for (uint32_t ct=0; ct < indent; ct++) { + si.append(" "); + } -ElementState::~ElementState() -{ + String8 s(si); + s.append("{\n"); + for (uint32_t ct = 0; ct < mFieldCount; ct++) { + s.append(si); + s.append(mFields[ct].e->getCType(indent+4)); + s.append(" "); + s.append(mFields[ct].name); + s.append(";\n"); + } + s.append(si); + s.append("}"); + return s; } +String8 Element::getCType(uint32_t indent) const +{ + String8 s; + for (uint32_t ct=0; ct < indent; ct++) { + s.append(" "); + } -///////////////////////////////////////// -// + if (!mFieldCount) { + // Basic component. + s.append(mComponent.getCType()); + } else { + s.append("struct "); + s.append(getCStructBody(indent)); + } -namespace android { -namespace renderscript { + return s; +} -void rsi_ElementBegin(Context *rsc) +String8 Element::getGLSLType(uint32_t indent) const { - ElementState * sec = &rsc->mStateElement; + String8 s; + for (uint32_t ct=0; ct < indent; ct++) { + s.append(" "); + } + + if (!mFieldCount) { + // Basic component. + s.append(mComponent.getGLSLType()); + } else { + rsAssert(0); + //s.append("struct "); + //s.append(getCStructBody(indent)); + } - sec->mBuildList.clear(); - sec->mNames.clear(); + return s; } -void rsi_ElementAdd(Context *rsc, RsDataKind dk, RsDataType dt, bool isNormalized, size_t bits, const char *name) -{ - ElementState * sec = &rsc->mStateElement; - rsAssert(bits > 0); - Element *c = Element::create(rsc, dk, dt, isNormalized, bits); - sec->mBuildList.add(c); - if (name) - sec->mNames.add(String8(name)); - else - sec->mNames.add(String8("")); +ElementState::ElementState() +{ } -RsElement rsi_ElementCreate(Context *rsc) +ElementState::~ElementState() { - ElementState * sec = &rsc->mStateElement; +} - size_t count = sec->mBuildList.size(); - rsAssert(count > 0); - if (count == 1) { - Element *se = sec->mBuildList[0]; - se->incUserRef(); - sec->mBuildList.clear(); - sec->mNames.clear(); - return se; - } +///////////////////////////////////////// +// - Element ** tmpElements = (Element **)calloc(count, sizeof(Element *)); - const char ** tmpNames = (const char **)calloc(count, sizeof(char *)); - size_t * tmpLengths = (size_t *)calloc(count, sizeof(size_t)); +namespace android { +namespace renderscript { +RsElement rsi_ElementCreate(Context *rsc, + RsDataType dt, + RsDataKind dk, + bool norm, + uint32_t vecSize) +{ + //LOGE("rsi_ElementCreate %i %i %i %i", dt, dk, norm, vecSize); + Element *e = Element::create(rsc, dt, dk, norm, vecSize); + e->incUserRef(); + return e; +} - for (size_t ct = 0; ct < count; ct++) { - tmpElements[ct] = sec->mBuildList[ct]; - tmpNames[ct] = sec->mNames[ct].string(); - tmpLengths[ct] = sec->mNames[ct].length(); - } - Element *se = Element::create(rsc, tmpElements, tmpNames, tmpLengths, count); - - sec->mBuildList.clear(); - sec->mNames.clear(); - se->incUserRef(); - free(tmpElements); - free(tmpNames); - free(tmpLengths); - return se; +RsElement rsi_ElementCreate2(Context *rsc, + size_t count, + const RsElement * ein, + const char ** names, + const size_t * nameLengths) +{ + //LOGE("rsi_ElementCreate2 %i", count); + Element *e = Element::create(rsc, count, (const Element **)ein, names, nameLengths); + e->incUserRef(); + return e; } diff --git a/libs/rs/rsElement.h b/libs/rs/rsElement.h index 43e2820..777e8ee 100644 --- a/libs/rs/rsElement.h +++ b/libs/rs/rsElement.h @@ -17,7 +17,7 @@ #ifndef ANDROID_STRUCTURED_ELEMENT_H #define ANDROID_STRUCTURED_ELEMENT_H -//#include "rsComponent.h" +#include "rsComponent.h" #include "rsUtils.h" #include "rsObjectBase.h" @@ -32,13 +32,9 @@ class Element : public ObjectBase public: ~Element(); - - //void setComponent(uint32_t idx, Component *c); - uint32_t getGLType() const; uint32_t getGLFormat() const; - size_t getSizeBits() const; size_t getSizeBytes() const { return (getSizeBits() + 7) >> 3; @@ -53,20 +49,21 @@ public: const Element * getField(uint32_t idx) const {return mFields[idx].e.get();} const char * getFieldName(uint32_t idx) const {return mFields[idx].name.string();} - RsDataType getType() const {return mType;} - bool getIsNormalized() const {return mIsNormalized;} - RsDataKind getKind() const {return mKind;} + const Component & getComponent() const {return mComponent;} + RsDataType getType() const {return mComponent.getType();} + RsDataKind getKind() const {return mComponent.getKind();} uint32_t getBits() const {return mBits;} - //uint32_t getGLType() const; - const char * getCType() const; - void dumpLOGV(const char *prefix) const; + String8 getCType(uint32_t indent=0) const; + String8 getCStructBody(uint32_t indent=0) const; + String8 getGLSLType(uint32_t indent=0) const; + void dumpLOGV(const char *prefix) const; - static Element * create(Context *rsc, RsDataKind dk, RsDataType dt, - bool isNorm, size_t bits); - static Element * create(Context *rsc, Element **, const char **, - const size_t * lengths, size_t count); + static Element * create(Context *rsc, RsDataType dt, RsDataKind dk, + bool isNorm, uint32_t vecSize); + static Element * create(Context *rsc, size_t count, const Element **, + const char **, const size_t * lengths); protected: // deallocate any components that are part of this element. @@ -74,7 +71,7 @@ protected: typedef struct { String8 name; - ObjectBaseRef<Element> e; + ObjectBaseRef<const Element> e; } ElementField_t; ElementField_t *mFields; size_t mFieldCount; @@ -82,12 +79,8 @@ protected: Element(Context *); - - RsDataType mType; - bool mIsNormalized; - RsDataKind mKind; + Component mComponent; uint32_t mBits; - //String8 mName; }; @@ -96,8 +89,6 @@ public: ElementState(); ~ElementState(); - Vector<Element *> mBuildList; - Vector<String8> mNames; }; diff --git a/libs/rs/rsFileA3D.cpp b/libs/rs/rsFileA3D.cpp index c566665..e3272c5 100644 --- a/libs/rs/rsFileA3D.cpp +++ b/libs/rs/rsFileA3D.cpp @@ -324,6 +324,7 @@ void FileA3D::processChunk_Verticies(Context *rsc, IO *io, A3DIndexEntry *ie) void FileA3D::processChunk_Element(Context *rsc, IO *io, A3DIndexEntry *ie) { + /* rsi_ElementBegin(rsc); uint32_t count = io->loadU32(); @@ -338,6 +339,7 @@ void FileA3D::processChunk_Element(Context *rsc, IO *io, A3DIndexEntry *ie) } LOGE("processChunk_Element create"); ie->mRsObj = rsi_ElementCreate(rsc); + */ } void FileA3D::processChunk_ElementSource(Context *rsc, IO *io, A3DIndexEntry *ie) diff --git a/libs/rs/rsProgram.cpp b/libs/rs/rsProgram.cpp index e6d1e36..b7639be 100644 --- a/libs/rs/rsProgram.cpp +++ b/libs/rs/rsProgram.cpp @@ -121,6 +121,66 @@ void Program::bindAllocation(Allocation *alloc) mDirty = true; } +void Program::bindTexture(uint32_t slot, Allocation *a) +{ + if (slot >= MAX_TEXTURE) { + LOGE("Attempt to bind a texture to a slot > MAX_TEXTURE"); + return; + } + + //LOGE("bindtex %i %p", slot, a); + mTextures[slot].set(a); + mDirty = true; +} + +void Program::bindSampler(uint32_t slot, Sampler *s) +{ + if (slot >= MAX_TEXTURE) { + LOGE("Attempt to bind a Sampler to a slot > MAX_TEXTURE"); + return; + } + + mSamplers[slot].set(s); + mDirty = true; +} + +String8 Program::getGLSLInputString() const +{ + String8 s; + for (uint32_t ct=0; ct < mInputCount; ct++) { + const Element *e = mInputElements[ct].get(); + for (uint32_t field=0; field < e->getFieldCount(); field++) { + const Element *f = e->getField(field); + + // Cannot be complex + rsAssert(!f->getFieldCount()); + switch(f->getComponent().getVectorSize()) { + case 1: s.append("attribute float ATTRIB_"); break; + case 2: s.append("attribute vec2 ATTRIB_"); break; + case 3: s.append("attribute vec3 ATTRIB_"); break; + case 4: s.append("attribute vec4 ATTRIB_"); break; + default: + rsAssert(0); + } + + s.append(e->getFieldName(field)); + s.append(";\n"); + } + } + return s; +} + +String8 Program::getGLSLOutputString() const +{ + return String8(); +} + +String8 Program::getGLSLConstantString() const +{ + return String8(); +} + + void Program::createShader() { } @@ -182,6 +242,17 @@ void rsi_ProgramBindConstants(Context *rsc, RsProgram vp, uint32_t slot, RsAlloc p->bindAllocation(static_cast<Allocation *>(constants)); } +void rsi_ProgramBindTexture(Context *rsc, RsProgram vpf, uint32_t slot, RsAllocation a) +{ + Program *p = static_cast<Program *>(vpf); + p->bindTexture(slot, static_cast<Allocation *>(a)); +} + +void rsi_ProgramBindSampler(Context *rsc, RsProgram vpf, uint32_t slot, RsSampler s) +{ + Program *p = static_cast<Program *>(vpf); + p->bindSampler(slot, static_cast<Sampler *>(s)); +} } } diff --git a/libs/rs/rsProgram.h b/libs/rs/rsProgram.h index 003498e..4bb7802 100644 --- a/libs/rs/rsProgram.h +++ b/libs/rs/rsProgram.h @@ -32,6 +32,7 @@ class Program : public ObjectBase public: const static uint32_t MAX_ATTRIBS = 8; const static uint32_t MAX_UNIFORMS = 16; + const static uint32_t MAX_TEXTURE = 2; Program(Context *); Program(Context *, const char * shaderText, uint32_t shaderLength, @@ -41,6 +42,11 @@ public: void bindAllocation(Allocation *); virtual void createShader(); + bool isUserProgram() const {return mUserShader.size() > 0;} + + void bindTexture(uint32_t slot, Allocation *); + void bindSampler(uint32_t slot, Sampler *); + uint32_t getShaderID() const {return mShaderID;} void setShader(const char *, uint32_t len); @@ -49,6 +55,10 @@ public: const String8 & getAttribName(uint32_t i) const {return mAttribNames[i];} const String8 & getUniformName(uint32_t i) const {return mUniformNames[i];} + String8 getGLSLInputString() const; + String8 getGLSLOutputString() const; + String8 getGLSLConstantString() const; + protected: // Components not listed in "in" will be passed though // unless overwritten by components in out. @@ -72,6 +82,15 @@ protected: String8 mAttribNames[MAX_ATTRIBS]; String8 mUniformNames[MAX_UNIFORMS]; + // The difference between Textures and Constants is how they are accessed + // Texture lookups go though a sampler which in effect converts normalized + // coordinates into type specific. Multiple samples may also be taken + // and filtered. + // + // Constants are strictly accessed by programetic loads. + ObjectBaseRef<Allocation> mTextures[MAX_TEXTURE]; + ObjectBaseRef<Sampler> mSamplers[MAX_TEXTURE]; + bool loadShader(Context *, uint32_t type); public: diff --git a/libs/rs/rsProgramFragment.cpp b/libs/rs/rsProgramFragment.cpp index c353301..00f19ae 100644 --- a/libs/rs/rsProgramFragment.cpp +++ b/libs/rs/rsProgramFragment.cpp @@ -26,18 +26,28 @@ using namespace android; using namespace android::renderscript; -ProgramFragment::ProgramFragment(Context *rsc, Element *in, Element *out, bool pointSpriteEnable) : +ProgramFragment::ProgramFragment(Context *rsc, const uint32_t * params, + uint32_t paramLength) : Program(rsc) { mAllocFile = __FILE__; mAllocLine = __LINE__; - for (uint32_t ct=0; ct < MAX_TEXTURE; ct++) { - mEnvModes[ct] = RS_TEX_ENV_MODE_REPLACE; - mTextureDimensions[ct] = 2; - } + rsAssert(paramLength = 5); + + mEnvModes[0] = (RsTexEnvMode)params[0]; + mTextureFormats[0] = params[1]; + mEnvModes[1] = (RsTexEnvMode)params[2]; + mTextureFormats[1] = params[3]; + mPointSpriteEnable = params[4] != 0; + mTextureEnableMask = 0; - mPointSpriteEnable = pointSpriteEnable; - mEnvModes[1] = RS_TEX_ENV_MODE_DECAL; + if (mEnvModes[0]) { + mTextureEnableMask |= 1; + } + if (mEnvModes[1]) { + mTextureEnableMask |= 2; + } + init(rsc); } ProgramFragment::ProgramFragment(Context *rsc, const char * shaderText, @@ -84,6 +94,9 @@ void ProgramFragment::setupGL(const Context *rsc, ProgramFragmentState *state) glBindTexture(GL_TEXTURE_2D, mTextures[ct]->getTextureID()); switch(mEnvModes[ct]) { + case RS_TEX_ENV_MODE_NONE: + rsAssert(0); + break; case RS_TEX_ENV_MODE_REPLACE: glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); break; @@ -123,6 +136,7 @@ void ProgramFragment::setupGL(const Context *rsc, ProgramFragmentState *state) } glActiveTexture(GL_TEXTURE0); mDirty = false; + rsc->checkError("ProgramFragment::setupGL"); } void ProgramFragment::setupGL2(const Context *rsc, ProgramFragmentState *state, ShaderCache *sc) @@ -157,8 +171,7 @@ void ProgramFragment::setupGL2(const Context *rsc, ProgramFragmentState *state, glActiveTexture(GL_TEXTURE0); mDirty = false; - - //LOGE("sgl2 frag2 %x", glGetError()); + rsc->checkError("ProgramFragment::setupGL2"); } void ProgramFragment::loadShader(Context *rsc) { @@ -200,9 +213,9 @@ void ProgramFragment::createShader() if (mTextureEnableMask) { if (mPointSpriteEnable) { - mShader.append(" vec2 tex0 = gl_PointCoord;\n"); + mShader.append(" vec2 t0 = gl_PointCoord;\n"); } else { - mShader.append(" vec2 tex0 = varTex0.xy;\n"); + mShader.append(" vec2 t0 = varTex0.xy;\n"); } } @@ -211,14 +224,43 @@ void ProgramFragment::createShader() while (mask) { if (mask & 1) { switch(mEnvModes[texNum]) { + case RS_TEX_ENV_MODE_NONE: + rsAssert(0); + break; case RS_TEX_ENV_MODE_REPLACE: - mShader.append(" col = texture2D(uni_Tex0, tex0);\n"); + switch(mTextureFormats[texNum]) { + case 1: + mShader.append(" col.a = texture2D(uni_Tex0, t0).a;\n"); + break; + case 2: + mShader.append(" col.rgba = texture2D(uni_Tex0, t0).rgba;\n"); + break; + case 3: + mShader.append(" col.rgb = texture2D(uni_Tex0, t0).rgb;\n"); + break; + case 4: + mShader.append(" col.rgba = texture2D(uni_Tex0, t0).rgba;\n"); + break; + } break; case RS_TEX_ENV_MODE_MODULATE: - mShader.append(" col *= texture2D(uni_Tex0, tex0);\n"); + switch(mTextureFormats[texNum]) { + case 1: + mShader.append(" col.a *= texture2D(uni_Tex0, t0).a;\n"); + break; + case 2: + mShader.append(" col.rgba *= texture2D(uni_Tex0, t0).rgba;\n"); + break; + case 3: + mShader.append(" col.rgb *= texture2D(uni_Tex0, t0).rgb;\n"); + break; + case 4: + mShader.append(" col.rgba *= texture2D(uni_Tex0, t0).rgba;\n"); + break; + } break; case RS_TEX_ENV_MODE_DECAL: - mShader.append(" col = texture2D(uni_Tex0, tex0);\n"); + mShader.append(" col = texture2D(uni_Tex0, t0);\n"); break; } @@ -235,69 +277,6 @@ void ProgramFragment::createShader() } } -void ProgramFragment::bindTexture(uint32_t slot, Allocation *a) -{ - if (slot >= MAX_TEXTURE) { - LOGE("Attempt to bind a texture to a slot > MAX_TEXTURE"); - return; - } - - //LOGE("bindtex %i %p", slot, a); - mTextures[slot].set(a); - mDirty = true; -} - -void ProgramFragment::bindSampler(uint32_t slot, Sampler *s) -{ - if (slot >= MAX_TEXTURE) { - LOGE("Attempt to bind a Sampler to a slot > MAX_TEXTURE"); - return; - } - - mSamplers[slot].set(s); - mDirty = true; -} - -void ProgramFragment::setType(uint32_t slot, const Element *e, uint32_t dim) -{ - if (slot >= MAX_TEXTURE) { - LOGE("Attempt to setType to a slot > MAX_TEXTURE"); - return; - } - - if (dim >= 4) { - LOGE("Attempt to setType to a dimension > 3"); - return; - } - - mTextureFormats[slot].set(e); - mTextureDimensions[slot] = dim; -} - -void ProgramFragment::setEnvMode(uint32_t slot, RsTexEnvMode env) -{ - if (slot >= MAX_TEXTURE) { - LOGE("Attempt to setEnvMode to a slot > MAX_TEXTURE"); - return; - } - - mEnvModes[slot] = env; -} - -void ProgramFragment::setTexEnable(uint32_t slot, bool enable) -{ - if (slot >= MAX_TEXTURE) { - LOGE("Attempt to setEnvMode to a slot > MAX_TEXTURE"); - return; - } - - uint32_t bit = 1 << slot; - mTextureEnableMask &= ~bit; - if (enable) { - mTextureEnableMask |= bit; - } -} - void ProgramFragment::init(Context *rsc) { mUniformCount = 2; @@ -320,7 +299,12 @@ ProgramFragmentState::~ProgramFragmentState() void ProgramFragmentState::init(Context *rsc, int32_t w, int32_t h) { - ProgramFragment *pf = new ProgramFragment(rsc, NULL, NULL, false); + uint32_t tmp[5] = { + RS_TEX_ENV_MODE_NONE, 0, + RS_TEX_ENV_MODE_NONE, 0, + 0 + }; + ProgramFragment *pf = new ProgramFragment(rsc, tmp, 5); mDefault.set(pf); pf->init(rsc); } @@ -335,52 +319,12 @@ void ProgramFragmentState::deinit(Context *rsc) namespace android { namespace renderscript { -void rsi_ProgramFragmentBegin(Context * rsc, RsElement in, RsElement out, bool pointSpriteEnable) -{ - delete rsc->mStateFragment.mPF; - rsc->mStateFragment.mPF = new ProgramFragment(rsc, (Element *)in, (Element *)out, pointSpriteEnable); -} - -void rsi_ProgramFragmentBindTexture(Context *rsc, RsProgramFragment vpf, uint32_t slot, RsAllocation a) +RsProgramFragment rsi_ProgramFragmentCreate(Context *rsc, + const uint32_t * params, + uint32_t paramLength) { - ProgramFragment *pf = static_cast<ProgramFragment *>(vpf); - pf->bindTexture(slot, static_cast<Allocation *>(a)); -} - -void rsi_ProgramFragmentBindSampler(Context *rsc, RsProgramFragment vpf, uint32_t slot, RsSampler s) -{ - ProgramFragment *pf = static_cast<ProgramFragment *>(vpf); - pf->bindSampler(slot, static_cast<Sampler *>(s)); -} - -void rsi_ProgramFragmentSetSlot(Context *rsc, uint32_t slot, bool enable, RsTexEnvMode env, RsType vt) -{ - const Type *t = static_cast<const Type *>(vt); - if (t) { - uint32_t dim = 1; - if (t->getDimY()) { - dim ++; - if (t->getDimZ()) { - dim ++; - } - } - rsc->mStateFragment.mPF->setType(slot, t->getElement(), dim); - } - rsc->mStateFragment.mPF->setEnvMode(slot, env); - rsc->mStateFragment.mPF->setTexEnable(slot, enable); -} - -void rsi_ProgramFragmentSetShader(Context *rsc, const char *txt, uint32_t len) -{ - rsc->mStateFragment.mPF->setShader(txt, len); -} - -RsProgramFragment rsi_ProgramFragmentCreate(Context *rsc) -{ - ProgramFragment *pf = rsc->mStateFragment.mPF; + ProgramFragment *pf = new ProgramFragment(rsc, params, paramLength); pf->incUserRef(); - pf->init(rsc); - rsc->mStateFragment.mPF = 0; return pf; } diff --git a/libs/rs/rsProgramFragment.h b/libs/rs/rsProgramFragment.h index 14b4ec3..9fa565d 100644 --- a/libs/rs/rsProgramFragment.h +++ b/libs/rs/rsProgramFragment.h @@ -28,11 +28,7 @@ class ProgramFragmentState; class ProgramFragment : public Program { public: - const static uint32_t MAX_TEXTURE = 2; - - - - ProgramFragment(Context *, Element *in, Element *out, bool pointSpriteEnable); + ProgramFragment(Context *, const uint32_t * params, uint32_t paramLength); ProgramFragment(Context *rsc, const char * shaderText, uint32_t shaderLength, const uint32_t * params, uint32_t paramLength); @@ -41,33 +37,14 @@ public: virtual void setupGL(const Context *, ProgramFragmentState *); virtual void setupGL2(const Context *, ProgramFragmentState *, ShaderCache *sc); - - void bindTexture(uint32_t slot, Allocation *); - void bindSampler(uint32_t slot, Sampler *); - void setType(uint32_t slot, const Element *, uint32_t dim); - - void setEnvMode(uint32_t slot, RsTexEnvMode); - void setTexEnable(uint32_t slot, bool); - virtual void createShader(); virtual void loadShader(Context *rsc); virtual void init(Context *rsc); - protected: - // The difference between Textures and Constants is how they are accessed - // Texture lookups go though a sampler which in effect converts normalized - // coordinates into type specific. Multiple samples may also be taken - // and filtered. - // - // Constants are strictly accessed by programetic loads. - ObjectBaseRef<Allocation> mTextures[MAX_TEXTURE]; - ObjectBaseRef<Sampler> mSamplers[MAX_TEXTURE]; - ObjectBaseRef<const Element> mTextureFormats[MAX_TEXTURE]; - uint32_t mTextureDimensions[MAX_TEXTURE]; - - // Hacks to create a program for now + uint32_t mTextureFormats[MAX_TEXTURE]; + uint32_t mTextureDimensions[MAX_TEXTURE]; RsTexEnvMode mEnvModes[MAX_TEXTURE]; uint32_t mTextureEnableMask; bool mPointSpriteEnable; diff --git a/libs/rs/rsProgramVertex.cpp b/libs/rs/rsProgramVertex.cpp index 058cd73..2be6a7d 100644 --- a/libs/rs/rsProgramVertex.cpp +++ b/libs/rs/rsProgramVertex.cpp @@ -116,12 +116,6 @@ void ProgramVertex::createShader() { mShader.setTo(""); - for (uint32_t ct=0; ct < mAttribCount; ct++) { - mShader.append("attribute vec4 "); - mShader.append(mAttribNames[ct]); - mShader.append(";\n"); - } - for (uint32_t ct=0; ct < mUniformCount; ct++) { mShader.append("uniform mat4 "); mShader.append(mUniformNames[ct]); @@ -132,17 +126,43 @@ void ProgramVertex::createShader() mShader.append("varying vec4 varTex0;\n"); if (mUserShader.length() > 1) { + for (uint32_t ct=0; ct < mInputCount; ct++) { + const Element *e = mInputElements[ct].get(); + for (uint32_t field=0; field < e->getFieldCount(); field++) { + const Element *f = e->getField(field); + + // Cannot be complex + rsAssert(!f->getFieldCount()); + switch(f->getComponent().getVectorSize()) { + case 1: mShader.append("attribute float ATTRIB_"); break; + case 2: mShader.append("attribute vec2 ATTRIB_"); break; + case 3: mShader.append("attribute vec3 ATTRIB_"); break; + case 4: mShader.append("attribute vec4 ATTRIB_"); break; + default: + rsAssert(0); + } + + mShader.append(e->getFieldName(field)); + mShader.append(";\n"); + } + } mShader.append(mUserShader); } else { + for (uint32_t ct=VertexArray::POSITION; ct < mAttribCount; ct++) { + mShader.append("attribute vec4 "); + mShader.append(mAttribNames[ct]); + mShader.append(";\n"); + } + mShader.append("void main() {\n"); - mShader.append(" gl_Position = uni_MVP * attrib_Position;\n"); - mShader.append(" gl_PointSize = attrib_PointSize.x;\n"); + mShader.append(" gl_Position = uni_MVP * ATTRIB_Position;\n"); + mShader.append(" gl_PointSize = ATTRIB_PointSize.x;\n"); - mShader.append(" varColor = attrib_Color;\n"); + mShader.append(" varColor = ATTRIB_Color;\n"); if (mTextureMatrixEnable) { - mShader.append(" varTex0 = uni_TexMatrix * attrib_T0;\n"); + mShader.append(" varTex0 = uni_TexMatrix * ATTRIB_Texture;\n"); } else { - mShader.append(" varTex0 = attrib_T0;\n"); + mShader.append(" varTex0 = ATTRIB_Texture;\n"); } //mShader.append(" pos.x = pos.x / 480.0;\n"); //mShader.append(" pos.y = pos.y / 800.0;\n"); @@ -158,6 +178,8 @@ void ProgramVertex::setupGL2(const Context *rsc, ProgramVertexState *state, Shad //return; } + glVertexAttrib4f(1, state->color[0], state->color[1], state->color[2], state->color[3]); + const float *f = static_cast<const float *>(mConstants->getPtr()); Matrix mvp; @@ -173,7 +195,7 @@ void ProgramVertex::setupGL2(const Context *rsc, ProgramVertexState *state, Shad } state->mLast.set(this); - //LOGE("sgl2 vtx2 %x", glGetError()); + rsc->checkError("ProgramVertex::setupGL2"); } void ProgramVertex::addLight(const Light *l) @@ -214,15 +236,37 @@ void ProgramVertex::transformToScreen(const Context *rsc, float *v4out, const fl mvp.vectorMultiply(v4out, v3in); } +void ProgramVertex::initAddUserAttrib(const Element *e) +{ + rsAssert(e->getFieldCount()); + for (uint32_t ct=0; ct < e->getFieldCount(); ct++) { + const Element *ce = e->getField(ct); + if (ce->getFieldCount()) { + initAddUserAttrib(ce); + } else { + String8 tmp("ATTRIB_"); + tmp.append(e->getFieldName(ct)); + mAttribNames[mAttribCount].setTo(tmp.string()); + mAttribCount++; + } + } +} + void ProgramVertex::init(Context *rsc) { - mAttribCount = 6; - mAttribNames[VertexArray::POSITION].setTo("attrib_Position"); - mAttribNames[VertexArray::COLOR].setTo("attrib_Color"); - mAttribNames[VertexArray::NORMAL].setTo("attrib_Normal"); - mAttribNames[VertexArray::POINT_SIZE].setTo("attrib_PointSize"); - mAttribNames[VertexArray::TEXTURE_0].setTo("attrib_T0"); - mAttribNames[VertexArray::TEXTURE_1].setTo("attrib_T1"); + if (mUserShader.size() > 0) { + mAttribCount = 0; + for (uint32_t ct=0; ct < mInputCount; ct++) { + initAddUserAttrib(mInputElements[ct].get()); + } + } else { + mAttribCount = 5; + mAttribNames[0].setTo("ATTRIB_Position"); + mAttribNames[1].setTo("ATTRIB_Color"); + mAttribNames[2].setTo("ATTRIB_Normal"); + mAttribNames[3].setTo("ATTRIB_PointSize"); + mAttribNames[4].setTo("ATTRIB_Texture"); + } mUniformCount = 2; mUniformNames[0].setTo("uni_MVP"); @@ -244,9 +288,7 @@ ProgramVertexState::~ProgramVertexState() void ProgramVertexState::init(Context *rsc, int32_t w, int32_t h) { - rsi_ElementBegin(rsc); - rsi_ElementAdd(rsc, RS_KIND_USER, RS_TYPE_FLOAT, false, 32, NULL); - RsElement e = rsi_ElementCreate(rsc); + RsElement e = Element::create(rsc, RS_TYPE_FLOAT_32, RS_KIND_USER, false, 1); rsi_TypeBegin(rsc, e); rsi_TypeAdd(rsc, RS_DIMENSION_X, 48); @@ -259,6 +301,11 @@ void ProgramVertexState::init(Context *rsc, int32_t w, int32_t h) pv->init(rsc); pv->bindAllocation(alloc); + color[0] = 1.f; + color[1] = 1.f; + color[2] = 1.f; + color[3] = 1.f; + updateSize(rsc, w, h); } diff --git a/libs/rs/rsProgramVertex.h b/libs/rs/rsProgramVertex.h index 4748acc..dcb988c 100644 --- a/libs/rs/rsProgramVertex.h +++ b/libs/rs/rsProgramVertex.h @@ -59,6 +59,9 @@ protected: // Hacks to create a program for now bool mTextureMatrixEnable; + +private: + void initAddUserAttrib(const Element *e); }; @@ -79,6 +82,7 @@ public: ObjectBaseRef<Type> mAllocType; + float color[4]; }; diff --git a/libs/rs/rsScriptC.cpp b/libs/rs/rsScriptC.cpp index 3fa9813..b7e0b86 100644 --- a/libs/rs/rsScriptC.cpp +++ b/libs/rs/rsScriptC.cpp @@ -137,7 +137,6 @@ void ScriptCState::runCompiler(Context *rsc, ScriptC *s) rsc->appendNameDefines(&tmp); appendDecls(&tmp); - rsc->appendVarDefines(&tmp); appendVarDefines(rsc, &tmp); appendTypes(rsc, &tmp); tmp.append("#line 1\n"); @@ -311,9 +310,15 @@ void ScriptCState::appendTypes(const Context *rsc, String8 *str) char buf[256]; String8 tmp; - str->append("struct vec2_s {float x; float y;};"); - str->append("struct vec3_s {float x; float y; float z;};"); - str->append("struct vec4_s {float x; float y; float z; float w;};"); + str->append("struct vecF32_2_s {float x; float y;};\n"); + str->append("struct vecF32_3_s {float x; float y; float z;};\n"); + str->append("struct vecF32_4_s {float x; float y; float z; float w;};\n"); + str->append("struct vecU8_4_s {char r; char g; char b; char a;};\n"); + str->append("#define vecF32_2_t struct vecF32_2_s\n"); + str->append("#define vecF32_3_t struct vecF32_3_s\n"); + str->append("#define vecF32_4_t struct vecF32_4_s\n"); + str->append("#define vecU8_4_t struct vecU8_4_s\n"); + str->append("#define vecI8_4_t struct vecU8_4_s\n"); for (size_t ct=0; ct < MAX_SCRIPT_BANKS; ct++) { const Type *t = mConstantBufferTypes[ct].get(); @@ -324,8 +329,9 @@ void ScriptCState::appendTypes(const Context *rsc, String8 *str) if (e->getName() && (e->getFieldCount() > 1)) { String8 s("struct struct_"); s.append(e->getName()); - appendElementBody(&s, e); + s.append(e->getCStructBody()); s.append(";\n"); + s.append("#define "); s.append(e->getName()); s.append("_t struct struct_"); @@ -337,45 +343,25 @@ void ScriptCState::appendTypes(const Context *rsc, String8 *str) str->append(s); } - if (t->getName()) { - for (size_t ct2=0; ct2 < e->getFieldCount(); ct2++) { - const Element *c = e->getField(ct2); - tmp.setTo("#define OFFSETOF_"); - tmp.append(t->getName()); - tmp.append("_"); - tmp.append(e->getFieldName(ct2)); - sprintf(buf, " %i\n", ct2); - tmp.append(buf); - if (rsc->props.mLogScripts) { - LOGV(tmp); - } - str->append(tmp); - } - } - if (mSlotNames[ct].length() > 0) { String8 s; - if (e->getFieldCount() > 1) { - if (e->getName()) { - // Use the named struct - s.setTo(e->getName()); - s.append("_t *"); - } else { - // create an struct named from the slot. - s.setTo("struct "); - s.append(mSlotNames[ct]); - s.append("_s"); - appendElementBody(&s, e); - s.append(";\n"); - s.append("struct "); - s.append(mSlotNames[ct]); - s.append("_s * "); - } + if (e->getName()) { + // Use the named struct + s.setTo(e->getName()); } else { - // Just make an array - s.setTo(e->getField(0)->getCType()); - s.append("_t *"); + // create an struct named from the slot. + s.setTo("struct "); + s.append(mSlotNames[ct]); + s.append("_s"); + s.append(e->getCStructBody()); + //appendElementBody(&s, e); + s.append(";\n"); + s.append("struct "); + s.append(mSlotNames[ct]); + s.append("_s"); } + + s.append(" * "); s.append(mSlotNames[ct]); s.append(";\n"); if (rsc->props.mLogScripts) { diff --git a/libs/rs/rsScriptC_Lib.cpp b/libs/rs/rsScriptC_Lib.cpp index 55a8391..8a0ab71 100644 --- a/libs/rs/rsScriptC_Lib.cpp +++ b/libs/rs/rsScriptC_Lib.cpp @@ -619,20 +619,20 @@ static void SC_vec2Rand(float *vec, float maxLen) static void SC_bindTexture(RsProgramFragment vpf, uint32_t slot, RsAllocation va) { GET_TLS(); - rsi_ProgramFragmentBindTexture(rsc, - static_cast<ProgramFragment *>(vpf), - slot, - static_cast<Allocation *>(va)); + rsi_ProgramBindTexture(rsc, + static_cast<ProgramFragment *>(vpf), + slot, + static_cast<Allocation *>(va)); } static void SC_bindSampler(RsProgramFragment vpf, uint32_t slot, RsSampler vs) { GET_TLS(); - rsi_ProgramFragmentBindSampler(rsc, - static_cast<ProgramFragment *>(vpf), - slot, - static_cast<Sampler *>(vs)); + rsi_ProgramBindSampler(rsc, + static_cast<ProgramFragment *>(vpf), + slot, + static_cast<Sampler *>(vs)); } @@ -689,9 +689,9 @@ static void SC_drawLine(float x1, float y1, float z1, VertexArray va; va.setPosition(2, GL_FLOAT, 12, (uint32_t)&vtx); if (rsc->checkVersion2_0()) { - va.setupGL2(&rsc->mStateVertexArray, &rsc->mShaderCache); + va.setupGL2(rsc, &rsc->mStateVertexArray, &rsc->mShaderCache); } else { - va.setupGL(&rsc->mStateVertexArray); + va.setupGL(rsc, &rsc->mStateVertexArray); } glDrawArrays(GL_LINES, 0, 2); @@ -707,9 +707,9 @@ static void SC_drawPoint(float x, float y, float z) VertexArray va; va.setPosition(1, GL_FLOAT, 12, (uint32_t)&vtx); if (rsc->checkVersion2_0()) { - va.setupGL2(&rsc->mStateVertexArray, &rsc->mShaderCache); + va.setupGL2(rsc, &rsc->mStateVertexArray, &rsc->mShaderCache); } else { - va.setupGL(&rsc->mStateVertexArray); + va.setupGL(rsc, &rsc->mStateVertexArray); } glDrawArrays(GL_POINTS, 0, 1); @@ -737,14 +737,12 @@ static void SC_drawQuadTexCoords(float x1, float y1, float z1, const float tex[] = {u1,v1, u2,v2, u3,v3, u4,v4}; VertexArray va; - va.setPosition(2, GL_FLOAT, 12, (uint32_t)&vtx); - va.setTexture(2, GL_FLOAT, 8, (uint32_t)&tex, 0); - //va.setTexture(2, GL_FLOAT, 8, (uint32_t)&tex, 1); - // + va.setPosition(3, GL_FLOAT, 12, (uint32_t)&vtx); + va.setTexture(2, GL_FLOAT, 8, (uint32_t)&tex); if (rsc->checkVersion2_0()) { - va.setupGL2(&rsc->mStateVertexArray, &rsc->mShaderCache); + va.setupGL2(rsc, &rsc->mStateVertexArray, &rsc->mShaderCache); } else { - va.setupGL(&rsc->mStateVertexArray); + va.setupGL(rsc, &rsc->mStateVertexArray); } @@ -842,9 +840,11 @@ static void SC_drawSimpleMeshRange(RsSimpleMesh vsm, uint32_t start, uint32_t le static void SC_color(float r, float g, float b, float a) { GET_TLS(); - if (rsc->checkVersion2_0()) { - glVertexAttrib4f(1, r, g, b, a); - } else { + rsc->mStateVertex.color[0] = r; + rsc->mStateVertex.color[1] = g; + rsc->mStateVertex.color[2] = b; + rsc->mStateVertex.color[3] = a; + if (!rsc->checkVersion2_0()) { glColor4f(r, g, b, a); } } @@ -1221,33 +1221,33 @@ ScriptCState::SymbolTable_t ScriptCState::gSyms[] = { // vec3 { "vec3Norm", (void *)&SC_vec3Norm, - "void", "(struct vec3_s *)" }, + "void", "(struct vecF32_3_s *)" }, { "vec3Length", (void *)&SC_vec3Length, - "float", "(struct vec3_s *)" }, + "float", "(struct vecF32_3_s *)" }, { "vec3Add", (void *)&SC_vec3Add, - "void", "(struct vec3_s *dest, struct vec3_s *lhs, struct vec3_s *rhs)" }, + "void", "(struct vecF32_3_s *dest, struct vecF32_3_s *lhs, struct vecF32_3_s *rhs)" }, { "vec3Sub", (void *)&SC_vec3Sub, - "void", "(struct vec3_s *dest, struct vec3_s *lhs, struct vec3_s *rhs)" }, + "void", "(struct vecF32_3_s *dest, struct vecF32_3_s *lhs, struct vecF32_3_s *rhs)" }, { "vec3Cross", (void *)&SC_vec3Cross, - "void", "(struct vec3_s *dest, struct vec3_s *lhs, struct vec3_s *rhs)" }, + "void", "(struct vecF32_3_s *dest, struct vecF32_3_s *lhs, struct vecF32_3_s *rhs)" }, { "vec3Dot", (void *)&SC_vec3Dot, - "float", "(struct vec3_s *lhs, struct vec3_s *rhs)" }, + "float", "(struct vecF32_3_s *lhs, struct vecF32_3_s *rhs)" }, { "vec3Scale", (void *)&SC_vec3Scale, - "void", "(struct vec3_s *lhs, float scale)" }, + "void", "(struct vecF32_3_s *lhs, float scale)" }, // vec4 { "vec4Norm", (void *)&SC_vec4Norm, - "void", "(struct vec4_s *)" }, + "void", "(struct vecF32_4_s *)" }, { "vec4Length", (void *)&SC_vec4Length, - "float", "(struct vec4_s *)" }, + "float", "(struct vecF32_4_s *)" }, { "vec4Add", (void *)&SC_vec4Add, - "void", "(struct vec4_s *dest, struct vec4_s *lhs, struct vec4_s *rhs)" }, + "void", "(struct vecF32_4_s *dest, struct vecF32_4_s *lhs, struct vecF32_4_s *rhs)" }, { "vec4Sub", (void *)&SC_vec4Sub, - "void", "(struct vec4_s *dest, struct vec4_s *lhs, struct vec4_s *rhs)" }, + "void", "(struct vecF32_4_s *dest, struct vecF32_4_s *lhs, struct vecF32_4_s *rhs)" }, { "vec4Dot", (void *)&SC_vec4Dot, - "float", "(struct vec4_s *lhs, struct vec4_s *rhs)" }, + "float", "(struct vecF32_4_s *lhs, struct vecF32_4_s *rhs)" }, { "vec4Scale", (void *)&SC_vec4Scale, - "void", "(struct vec4_s *lhs, float scale)" }, + "void", "(struct vecF32_4_s *lhs, float scale)" }, // context { "bindProgramFragment", (void *)&SC_bindProgramFragment, diff --git a/libs/rs/rsShaderCache.cpp b/libs/rs/rsShaderCache.cpp index 8e2af34..0d9863d 100644 --- a/libs/rs/rsShaderCache.cpp +++ b/libs/rs/rsShaderCache.cpp @@ -59,6 +59,7 @@ bool ShaderCache::lookup(Context *rsc, ProgramVertex *vtx, ProgramFragment *frag glUseProgram(mEntries[ct].program); mCurrent = &mEntries[ct]; //LOGV("ShaderCache hit, using %i", ct); + rsc->checkError("ShaderCache::lookup (hit)"); return true; } } @@ -91,9 +92,15 @@ bool ShaderCache::lookup(Context *rsc, ProgramVertex *vtx, ProgramFragment *frag //LOGE("e1 %x", glGetError()); glAttachShader(pgm, frag->getShaderID()); - glBindAttribLocation(pgm, VertexArray::POSITION, "attrib_Position"); - glBindAttribLocation(pgm, VertexArray::COLOR, "attrib_Color"); + if (!vtx->isUserProgram()) { + glBindAttribLocation(pgm, VertexArray::POSITION, "ATTRIB_Position"); + glBindAttribLocation(pgm, VertexArray::COLOR, "ATTRIB_Color"); + glBindAttribLocation(pgm, VertexArray::NORMAL, "ATTRIB_Normal"); + glBindAttribLocation(pgm, VertexArray::POINT_SIZE, "ATTRIB_PointSize"); + glBindAttribLocation(pgm, VertexArray::TEXTURE, "ATTRIB_T0"); + } else { + } //LOGE("e2 %x", glGetError()); glLinkProgram(pgm); @@ -116,7 +123,7 @@ bool ShaderCache::lookup(Context *rsc, ProgramVertex *vtx, ProgramFragment *frag for (uint32_t ct=0; ct < vtx->getAttribCount(); ct++) { e->mVtxAttribSlots[ct] = glGetAttribLocation(pgm, vtx->getAttribName(ct)); if (rsc->props.mLogShaders) { - LOGV("vtx A, %s = %d\n", vtx->getAttribName(ct).string(), e->mVtxAttribSlots[ct]); + LOGV("vtx A %i, %s = %d\n", ct, vtx->getAttribName(ct).string(), e->mVtxAttribSlots[ct]); } } for (uint32_t ct=0; ct < vtx->getUniformCount(); ct++) { @@ -136,6 +143,7 @@ bool ShaderCache::lookup(Context *rsc, ProgramVertex *vtx, ProgramFragment *frag //LOGV("SC made program %i", e->program); glUseProgram(e->program); mEntryCount++; + rsc->checkError("ShaderCache::lookup (miss)"); return true; } diff --git a/libs/rs/rsSimpleMesh.cpp b/libs/rs/rsSimpleMesh.cpp index f7d14a5..a819c07 100644 --- a/libs/rs/rsSimpleMesh.cpp +++ b/libs/rs/rsSimpleMesh.cpp @@ -55,18 +55,25 @@ void SimpleMesh::renderRange(Context *rsc, uint32_t start, uint32_t len) const return; } + rsc->checkError("SimpleMesh::renderRange 1"); VertexArray va; - for (uint32_t ct=0; ct < mVertexTypeCount; ct++) { - mVertexBuffers[ct]->uploadCheck(rsc); - va.setActiveBuffer(mVertexBuffers[ct]->getBufferObjectID()); - mVertexTypes[ct]->enableGLVertexBuffer(&va); - } if (rsc->checkVersion2_0()) { - va.setupGL2(0, &rsc->mShaderCache); + for (uint32_t ct=0; ct < mVertexTypeCount; ct++) { + mVertexBuffers[ct]->uploadCheck(rsc); + va.setActiveBuffer(mVertexBuffers[ct]->getBufferObjectID()); + mVertexTypes[ct]->enableGLVertexBuffer2(&va); + } + va.setupGL2(rsc, 0, &rsc->mShaderCache); } else { - va.setupGL(0); + for (uint32_t ct=0; ct < mVertexTypeCount; ct++) { + mVertexBuffers[ct]->uploadCheck(rsc); + va.setActiveBuffer(mVertexBuffers[ct]->getBufferObjectID()); + mVertexTypes[ct]->enableGLVertexBuffer(&va); + } + va.setupGL(rsc, 0); } + rsc->checkError("SimpleMesh::renderRange 2"); if (mIndexType.get()) { mIndexBuffer->uploadCheck(rsc); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBuffer->getBufferObjectID()); @@ -74,6 +81,8 @@ void SimpleMesh::renderRange(Context *rsc, uint32_t start, uint32_t len) const } else { glDrawArrays(mGLPrimitive, start, len); } + + rsc->checkError("SimpleMesh::renderRange"); } void SimpleMesh::uploadAll(Context *rsc) @@ -89,6 +98,7 @@ void SimpleMesh::uploadAll(Context *rsc) if (mPrimitiveBuffer.get()) { mPrimitiveBuffer->deferedUploadToBufferObject(rsc); } + rsc->checkError("SimpleMesh::uploadAll"); } diff --git a/libs/rs/rsType.cpp b/libs/rs/rsType.cpp index 5eac0b5..d3b53d6 100644 --- a/libs/rs/rsType.cpp +++ b/libs/rs/rsType.cpp @@ -26,7 +26,6 @@ Type::Type(Context *rsc) : ObjectBase(rsc) mAllocLine = __LINE__; mLODs = 0; mLODCount = 0; - memset(&mGL, 0, sizeof(mGL)); clear(); } @@ -133,110 +132,64 @@ uint32_t Type::getLODOffset(uint32_t lod, uint32_t x, uint32_t y, uint32_t z) co void Type::makeGLComponents() { - uint32_t texNum = 0; - memset(&mGL, 0, sizeof(mGL)); + uint32_t userNum = 0; for (uint32_t ct=0; ct < getElement()->getFieldCount(); ct++) { - const Element *c = getElement()->getField(ct); + const Component &c = getElement()->getField(ct)->getComponent(); + + switch(c.getKind()) { + case RS_KIND_USER: + mGL.mUser[userNum].size = c.getVectorSize(); + mGL.mUser[userNum].offset = mElement->getFieldOffsetBytes(ct); + mGL.mUser[userNum].type = c.getGLType(); + mGL.mUser[userNum].normalized = c.getType() != RS_TYPE_FLOAT_32;//c.getIsNormalized(); + mGL.mUser[userNum].name.setTo(getElement()->getFieldName(ct)); + userNum ++; + break; - switch(c->getKind()) { - case RS_KIND_X: + case RS_KIND_POSITION: rsAssert(mGL.mVtx.size == 0); - mGL.mVtx.size = 1; + mGL.mVtx.size = c.getVectorSize(); mGL.mVtx.offset = mElement->getFieldOffsetBytes(ct); - mGL.mVtx.type = c->getGLType(); - break; - case RS_KIND_Y: - rsAssert(mGL.mVtx.size == 1); - rsAssert(mGL.mVtx.type == c->getGLType()); - mGL.mVtx.size = 2; + mGL.mVtx.type = c.getGLType(); + mGL.mVtx.normalized = false; + mGL.mVtx.name.setTo("Position"); break; - case RS_KIND_Z: - rsAssert(mGL.mVtx.size == 2); - rsAssert(mGL.mVtx.type == c->getGLType()); - mGL.mVtx.size = 3; - break; - case RS_KIND_W: - rsAssert(mGL.mVtx.size == 4); - rsAssert(mGL.mVtx.type == c->getGLType()); - mGL.mVtx.size = 4; - break; - case RS_KIND_RED: + case RS_KIND_COLOR: rsAssert(mGL.mColor.size == 0); - mGL.mColor.size = 1; + mGL.mColor.size = c.getVectorSize(); mGL.mColor.offset = mElement->getFieldOffsetBytes(ct); - mGL.mColor.type = c->getGLType(); + mGL.mColor.type = c.getGLType(); + mGL.mColor.normalized = c.getType() != RS_TYPE_FLOAT_32; + mGL.mColor.name.setTo("Color"); break; - case RS_KIND_GREEN: - rsAssert(mGL.mColor.size == 1); - rsAssert(mGL.mColor.type == c->getGLType()); - mGL.mColor.size = 2; - break; - case RS_KIND_BLUE: - rsAssert(mGL.mColor.size == 2); - rsAssert(mGL.mColor.type == c->getGLType()); - mGL.mColor.size = 3; - break; - case RS_KIND_ALPHA: - // Can be RGBA or A at this point - if (mGL.mColor.size > 0) { - rsAssert(mGL.mColor.size == 3); - rsAssert(mGL.mColor.type == c->getGLType()); - mGL.mColor.size = 4; - } else { - mGL.mColor.size = 1; - mGL.mColor.offset = mElement->getFieldOffsetBytes(ct); - mGL.mColor.type = c->getGLType(); - } - break; - case RS_KIND_NX: + case RS_KIND_NORMAL: rsAssert(mGL.mNorm.size == 0); - mGL.mNorm.size = 1; + mGL.mNorm.size = c.getVectorSize(); mGL.mNorm.offset = mElement->getFieldOffsetBytes(ct); - mGL.mNorm.type = c->getGLType(); - break; - case RS_KIND_NY: - rsAssert(mGL.mNorm.size == 1); - rsAssert(mGL.mNorm.type == c->getGLType()); - mGL.mNorm.size = 2; - break; - case RS_KIND_NZ: - rsAssert(mGL.mNorm.size == 2); - rsAssert(mGL.mNorm.type == c->getGLType()); - mGL.mNorm.size = 3; - break; + mGL.mNorm.type = c.getGLType(); + mGL.mNorm.normalized = false; + mGL.mNorm.name.setTo("Normal"); + break; - case RS_KIND_S: - if (mGL.mTex[texNum].size) { - texNum++; - } - mGL.mTex[texNum].size = 1; - mGL.mTex[texNum].offset = mElement->getFieldOffsetBytes(ct); - mGL.mTex[texNum].type = c->getGLType(); - break; - case RS_KIND_T: - rsAssert(mGL.mTex[texNum].size == 1); - rsAssert(mGL.mTex[texNum].type == c->getGLType()); - mGL.mTex[texNum].size = 2; - break; - case RS_KIND_R: - rsAssert(mGL.mTex[texNum].size == 2); - rsAssert(mGL.mTex[texNum].type == c->getGLType()); - mGL.mTex[texNum].size = 3; - break; - case RS_KIND_Q: - rsAssert(mGL.mTex[texNum].size == 3); - rsAssert(mGL.mTex[texNum].type == c->getGLType()); - mGL.mTex[texNum].size = 4; - break; + case RS_KIND_TEXTURE: + rsAssert(mGL.mTex.size == 0); + mGL.mTex.size = c.getVectorSize(); + mGL.mTex.offset = mElement->getFieldOffsetBytes(ct); + mGL.mTex.type = c.getGLType(); + mGL.mTex.normalized = false; + mGL.mTex.name.setTo("Texture"); + break; case RS_KIND_POINT_SIZE: rsAssert(!mGL.mPointSize.size); - mGL.mPointSize.size = 1; + mGL.mPointSize.size = c.getVectorSize(); mGL.mPointSize.offset = mElement->getFieldOffsetBytes(ct); - mGL.mPointSize.type = c->getGLType(); + mGL.mPointSize.type = c.getGLType(); + mGL.mPointSize.normalized = false; + mGL.mPointSize.name.setTo("PointSize"); break; default: @@ -248,7 +201,7 @@ void Type::makeGLComponents() void Type::enableGLVertexBuffer(VertexArray *va) const { // Note: We are only going to enable buffers and never disable them - // here. The reasonis more than one Allocation may be used as a vertex + // here. The reason is more than one Allocation may be used as a vertex // source. So we cannot disable arrays that may have been in use by // another allocation. @@ -273,14 +226,11 @@ void Type::enableGLVertexBuffer(VertexArray *va) const mGL.mColor.offset); } - for (uint32_t ct=0; ct < RS_MAX_TEXTURE; ct++) { - if (mGL.mTex[ct].size) { - va->setTexture(mGL.mTex[ct].size, - mGL.mTex[ct].type, - stride, - mGL.mTex[ct].offset, - ct); - } + if (mGL.mTex.size) { + va->setTexture(mGL.mTex.size, + mGL.mTex.type, + stride, + mGL.mTex.offset); } if (mGL.mPointSize.size) { @@ -291,6 +241,20 @@ void Type::enableGLVertexBuffer(VertexArray *va) const } +void Type::enableGLVertexBuffer2(VertexArray *va) const +{ + // Do legacy buffers + enableGLVertexBuffer(va); + + uint32_t stride = mElement->getSizeBytes(); + for (uint32_t ct=0; ct < RS_MAX_ATTRIBS; ct++) { + if (mGL.mUser[ct].size) { + va->setUser(mGL.mUser[ct], stride); + } + } +} + + void Type::dumpLOGV(const char *prefix) const { diff --git a/libs/rs/rsType.h b/libs/rs/rsType.h index d261d58..4fa4933 100644 --- a/libs/rs/rsType.h +++ b/libs/rs/rsType.h @@ -18,6 +18,7 @@ #define ANDROID_STRUCTURED_TYPE_H #include "rsElement.h" +#include "rsVertexArray.h" // --------------------------------------------------------------------------- namespace android { @@ -68,6 +69,7 @@ public: void compute(); void enableGLVertexBuffer(class VertexArray *) const; + void enableGLVertexBuffer2(class VertexArray *) const; void dumpLOGV(const char *prefix) const; @@ -108,18 +110,13 @@ protected: LOD *mLODs; uint32_t mLODCount; - struct VertexComponent_t { - uint32_t offset; - uint32_t type; - uint32_t size; - uint32_t stride; - }; struct GLState_t { - VertexComponent_t mVtx; - VertexComponent_t mNorm; - VertexComponent_t mColor; - VertexComponent_t mTex[RS_MAX_TEXTURE]; - VertexComponent_t mPointSize; + VertexArray::Attrib mUser[RS_MAX_ATTRIBS]; + VertexArray::Attrib mVtx; + VertexArray::Attrib mNorm; + VertexArray::Attrib mColor; + VertexArray::Attrib mTex; + VertexArray::Attrib mPointSize; }; GLState_t mGL; void makeGLComponents(); diff --git a/libs/rs/rsVertexArray.cpp b/libs/rs/rsVertexArray.cpp index 34d42ed..7a8e054 100644 --- a/libs/rs/rsVertexArray.cpp +++ b/libs/rs/rsVertexArray.cpp @@ -25,8 +25,8 @@ using namespace android::renderscript; VertexArray::VertexArray() { - memset(mAttribs, 0, sizeof(mAttribs)); mActiveBuffer = 0; + mUserCount = 0; } VertexArray::~VertexArray() @@ -36,13 +36,43 @@ VertexArray::~VertexArray() void VertexArray::clearAll() { - memset(mAttribs, 0, sizeof(mAttribs)); + for (uint32_t ct=0; ct < RS_MAX_ATTRIBS; ct++) { + mAttribs[ct].clear(); + } mActiveBuffer = 0; + mUserCount = 0; +} + +VertexArray::Attrib::Attrib() +{ + clear(); +} + +void VertexArray::Attrib::set(const Attrib &a) +{ + buffer = a.buffer; + offset = a.offset; + type = a.type; + size = a.size; + stride = a.stride; + normalized = a.normalized; + name.setTo(a.name); +} + +void VertexArray::Attrib::clear() +{ + buffer = 0; + offset = 0; + type = 0; + size = 0; + stride = 0; + normalized = false; + name.setTo(""); } void VertexArray::clear(AttribName n) { - mAttribs[n].size = 0; + mAttribs[n].clear(); } void VertexArray::setPosition(uint32_t size, uint32_t type, uint32_t stride, uint32_t offset) @@ -85,26 +115,36 @@ void VertexArray::setPointSize(uint32_t type, uint32_t stride, uint32_t offset) mAttribs[POINT_SIZE].normalized = false; } -void VertexArray::setTexture(uint32_t size, uint32_t type, uint32_t stride, uint32_t offset, uint32_t num) +void VertexArray::setTexture(uint32_t size, uint32_t type, uint32_t stride, uint32_t offset) +{ + mAttribs[TEXTURE].buffer = mActiveBuffer; + mAttribs[TEXTURE].type = type; + mAttribs[TEXTURE].size = size; + mAttribs[TEXTURE].offset = offset; + mAttribs[TEXTURE].stride = stride; + mAttribs[TEXTURE].normalized = false; +} + +void VertexArray::setUser(const Attrib &a, uint32_t stride) { - mAttribs[TEXTURE_0 + num].buffer = mActiveBuffer; - mAttribs[TEXTURE_0 + num].type = type; - mAttribs[TEXTURE_0 + num].size = size; - mAttribs[TEXTURE_0 + num].offset = offset; - mAttribs[TEXTURE_0 + num].stride = stride; - mAttribs[TEXTURE_0 + num].normalized = false; + mAttribs[mUserCount].set(a); + mAttribs[mUserCount].buffer = mActiveBuffer; + mAttribs[mUserCount].stride = stride; + mUserCount ++; } -void VertexArray::logAttrib(uint32_t idx) const { - LOGE("va %i: buf=%i size=%i type=0x%x stride=0x%x offset=0x%x", idx, +void VertexArray::logAttrib(uint32_t idx, uint32_t slot) const { + LOGE("va %i: slot=%i name=%s buf=%i size=%i type=0x%x stride=0x%x norm=%i offset=0x%x", idx, slot, + mAttribs[idx].name.string(), mAttribs[idx].buffer, mAttribs[idx].size, mAttribs[idx].type, mAttribs[idx].stride, + mAttribs[idx].normalized, mAttribs[idx].offset); } -void VertexArray::setupGL(class VertexArrayState *state) const +void VertexArray::setupGL(const Context *rsc, class VertexArrayState *state) const { if (mAttribs[POSITION].size) { //logAttrib(POSITION); @@ -142,21 +182,18 @@ void VertexArray::setupGL(class VertexArrayState *state) const glDisableClientState(GL_COLOR_ARRAY); } - for (uint32_t ct=0; ct < RS_MAX_TEXTURE; ct++) { - glClientActiveTexture(GL_TEXTURE0 + ct); - if (mAttribs[TEXTURE_0 + ct].size) { - //logAttrib(TEXTURE_0 + ct); - glEnableClientState(GL_TEXTURE_COORD_ARRAY); - glBindBuffer(GL_ARRAY_BUFFER, mAttribs[TEXTURE_0 + ct].buffer); - glTexCoordPointer(mAttribs[TEXTURE_0 + ct].size, - mAttribs[TEXTURE_0 + ct].type, - mAttribs[TEXTURE_0 + ct].stride, - (void *)mAttribs[TEXTURE_0 + ct].offset); - } else { - glDisableClientState(GL_TEXTURE_COORD_ARRAY); - } - } glClientActiveTexture(GL_TEXTURE0); + if (mAttribs[TEXTURE].size) { + //logAttrib(TEXTURE); + glEnableClientState(GL_TEXTURE_COORD_ARRAY); + glBindBuffer(GL_ARRAY_BUFFER, mAttribs[TEXTURE].buffer); + glTexCoordPointer(mAttribs[TEXTURE].size, + mAttribs[TEXTURE].type, + mAttribs[TEXTURE].stride, + (void *)mAttribs[TEXTURE].offset); + } else { + glDisableClientState(GL_TEXTURE_COORD_ARRAY); + } if (mAttribs[POINT_SIZE].size) { //logAttrib(POINT_SIZE); @@ -168,20 +205,21 @@ void VertexArray::setupGL(class VertexArrayState *state) const } else { glDisableClientState(GL_POINT_SIZE_ARRAY_OES); } + rsc->checkError("VertexArray::setupGL"); } -void VertexArray::setupGL2(class VertexArrayState *state, ShaderCache *sc) const +void VertexArray::setupGL2(const Context *rsc, class VertexArrayState *state, ShaderCache *sc) const { for (int ct=1; ct < _LAST; ct++) { glDisableVertexAttribArray(ct); } - for (int ct=0; ct < _LAST; ct++) { + for (uint32_t ct=0; ct < RS_MAX_ATTRIBS; ct++) { if (mAttribs[ct].size) { - //logAttrib(ct); + //logAttrib(ct, sc->vtxAttribSlot(ct)); + rsAssert(sc->vtxAttribSlot(ct) >= 0); glEnableVertexAttribArray(sc->vtxAttribSlot(ct)); glBindBuffer(GL_ARRAY_BUFFER, mAttribs[ct].buffer); - //LOGV("attp %i %i", ct, sc->vtxAttribSlot(ct)); glVertexAttribPointer(sc->vtxAttribSlot(ct), mAttribs[ct].size, @@ -189,15 +227,12 @@ void VertexArray::setupGL2(class VertexArrayState *state, ShaderCache *sc) const mAttribs[ct].normalized, mAttribs[ct].stride, (void *)mAttribs[ct].offset); - } else { - //glDisableVertexAttribArray(ct); - rsAssert(ct); } } + rsc->checkError("VertexArray::setupGL2"); } //////////////////////////////////////////// void VertexArrayState::init(Context *) { - memset(this, 0, sizeof(this)); } diff --git a/libs/rs/rsVertexArray.h b/libs/rs/rsVertexArray.h index 235ffef..998e9ad 100644 --- a/libs/rs/rsVertexArray.h +++ b/libs/rs/rsVertexArray.h @@ -38,19 +38,24 @@ public: COLOR, NORMAL, POINT_SIZE, - TEXTURE_0, - TEXTURE_1, + TEXTURE, _LAST }; - typedef struct { + class Attrib { + public: uint32_t buffer; uint32_t offset; uint32_t type; uint32_t size; uint32_t stride; bool normalized; - } Attrib; + String8 name; + + Attrib(); + void set(const Attrib &); + void clear(); + }; void clearAll(); @@ -58,19 +63,21 @@ public: void setActiveBuffer(uint32_t id) {mActiveBuffer = id;} + void setUser(const Attrib &, uint32_t stride); void setPosition(uint32_t size, uint32_t type, uint32_t stride, uint32_t offset); void setColor(uint32_t size, uint32_t type, uint32_t stride, uint32_t offset); void setNormal(uint32_t type, uint32_t stride, uint32_t offset); void setPointSize(uint32_t type, uint32_t stride, uint32_t offset); - void setTexture(uint32_t size, uint32_t type, uint32_t stride, uint32_t offset, uint32_t num); + void setTexture(uint32_t size, uint32_t type, uint32_t stride, uint32_t offset); - void setupGL(class VertexArrayState *) const; - void setupGL2(class VertexArrayState *, ShaderCache *) const; - void logAttrib(uint32_t idx) const; + void setupGL(const Context *rsc, class VertexArrayState *) const; + void setupGL2(const Context *rsc, class VertexArrayState *, ShaderCache *) const; + void logAttrib(uint32_t idx, uint32_t slot) const; protected: uint32_t mActiveBuffer; - Attrib mAttribs[_LAST]; + uint32_t mUserCount; + Attrib mAttribs[RS_MAX_ATTRIBS]; }; @@ -78,7 +85,7 @@ class VertexArrayState { public: void init(Context *); - VertexArray::Attrib mAttribs[VertexArray::_LAST]; + //VertexArray::Attrib mAttribs[VertexArray::_LAST]; }; |